import compile from './compile'
Copyright @ 2015-2016 JC Fisher
The library includes functions for logic, math, text, lookup, date/time, aggregation, arrays, objects, finance, statistics and other utilities.
import compile from './compile'
import run from './run'
import branch from './branch'
define cond
alias for branch
const cond = branch
import choose from './choose'
import and from './and'
import or from './or'
import not from './not'
eq
returns true when the first and second arguments are equivalent. String comparision is case insensitive.
import eq from './eq'
ne
returns true when the first and second arguments are not equivalent. String comparision is case insensitive.
import ne from './ne'
import gt from './gt'
import gte from './gte'
import lt from './lt'
import lte from './lte'
ifempty
returns the second argument when the first argument is blank or the third argument
import ifblank from './ifblank'
const ifBlank = ifblank
ifempty
returns the second argument when the first argument is empty or the third argument
import ifempty from './ifempty'
const ifEmpty = ifempty
ifempty
returns the second argument when the first argument is an error or the third argument
import iferror from './iferror'
const ifError = iferror
import ifna from './ifna'
const ifNA = ifna
import isarray from './isarray'
const isArray = isarray
import isblank from './isblank'
const isBlank = isblank
import isboolean from './isboolean'
const isbool = isboolean
const isBoolean = isboolean
const isBool = isboolean
import isdate from './isdate'
const isDate = isdate
import isemail from './isemail'
const isEmail = isemail
import isempty from './isempty'
const isEmpty = isempty
import iserror from './iserror'
const isError = iserror
import iseven from './iseven'
const isEven = iseven
import isfalsy from './isfalsy'
const isFalsy = isfalsy
import isfunction from './isfunction'
const isFunction = isfunction
import isleapyear from './isleapyear'
const isLeapYear = isleapyear
import isna from './isna'
const isNA = isna
isnumber
returns true when the value is JavaScript number type and not NaN and not infinite.
import isnumber from './isnumber'
const isNumber = isnumber
import isodd from './isodd'
const isOdd = isodd
import isoweeknum from './isoweeknum'
const isoWeekNum = isoweeknum
import isref from './isref'
const isRef = isref
import istext from './istext'
const isText = istext
import istruthy from './istruthy'
const isTruthy = istruthy
import isurl from './isurl'
const isURL = isurl
import iswholenumber from './iswholenumber'
const isWholeNumber = iswholenumber
const isInteger = iswholenumber
import xor from './xor'
import add from './add'
import subtract from './subtract'
import multiply from './multiply'
import divide from './divide'
import abs from './abs'
import acos from './acos'
import cos from './cos'
import pi from './pi'
import power from './power'
import round from './round'
import roundup from './roundup'
import sin from './sin'
import tan from './tan'
import tau from './tau'
import trunc from './trunc'
import char from './char'
import code from './code'
import concatenate from './concatenate'
const concat = concatenate
import exact from './exact'
import find from './find'
import join from './join'
import left from './left'
import len from './len'
import lower from './lower'
import numbervalue from './numbervalue'
const numberValue = numbervalue
import parsebool from './parsebool'
const parseBool = parsebool
import parsedate from './parsedate'
const parseDate = parsedate
import parsequery from './parsequery'
const parseQuery = parsequery
import proper from './proper'
import replace from './replace'
import right from './right'
import rept from './rept'
search
returns the index of a value inside a string with wildcard support for single characters (?) and multiple characters (*).
import search from './search'
import substitute from './substitute'
import substituteAll from './substituteAll'
const template = substituteAll
surroundKeys
returns a new object where the keys have been wrapped with start and end strings.
import surroundKeys from './surroundKeys'
import split from './split'
import text from './text'
import trim from './trim'
import upper from './upper'
hlookup
searches the first row and returns the value from the found column at a given row.
import hlookup from './hlookup'
import includes from './includes'
import index from './index'
lookup
searches an array and returns the value found or (optionally) the value at the same index in a second array.
import lookup from './lookup'
match
searches an array and returns the found index with support for wildcard and range queries.
import match from './match'
vlookup
searches the first column and returns the value from the found row at a given column.
import vlookup from './vlookup'
import date from './date'
import datevalue from './datevalue'
const dateValue = datevalue
import datedif from './datedif'
import day from './day'
import days360 from './days360'
edate
returns the serial number for a date that is a given number of months before or after a given date.
import edate from './edate'
import eomonth from './eomonth'
import hour from './hour'
import minute from './minute'
import month from './month'
import now from './now'
import second from './second'
import today from './today'
import time from './time'
import timevalue from './timevalue'
import year from './year'
import yearfrac from './yearfrac'
import average from './average'
import min from './min'
import max from './max'
import query from './query'
import sum from './sum'
import fv from './fv'
import nper from './nper'
import npv from './npv'
import pmt from './pmt'
import pv from './pv'
import bin2dec from './bin2dec'
import dec2bin from './dec2bin'
import oct2dec from './oct2dec'
import filter from './filter'
import flatten from './flatten'
import map from './map'
import pluck from './pluck'
import reduce from './reduce'
import some from './some'
import sort from './sort'
import unique from './unique'
import changed from './changed'
import diff from './diff'
import clean from './clean'
import get from './get'
import select from './select'
import cellindex from './cellindex'
const cellIndex = cellindex
import column from './column'
import columnletter from './columnletter'
const columnLetter = columnletter
import columnnumber from './columnnumber'
import decodebase64 from './decodebase64'
const decodeBase64 = decodebase64
const atob = decodebase64
import decodejwt from './decodejwt'
const decodeJWT = decodejwt
import guid from './guid'
import int from './int'
import index2col from './index2col'
import index2row from './index2row'
import n from './n'
import numbers from './numbers'
import ref from './ref'
import serial from './serial'
export default {
run,
compile,
abs,
acos,
add,
and,
atob,
average,
bin2dec,
branch,
cellIndex,
cellindex,
changed,
char,
choose,
clean,
code,
column,
columnLetter,
columnletter,
columnnumber,
concat,
concatenate,
cond,
cos,
date,
dateValue,
datedif,
datevalue,
day,
days360,
dec2bin,
decodeBase64,
decodeJWT,
decodebase64,
decodejwt,
diff,
divide,
edate,
eomonth,
eq,
exact,
filter,
find,
flatten,
fv,
get,
gt,
gte,
guid,
hlookup,
hour,
ifBlank,
ifEmpty,
ifError,
ifNA,
ifblank,
ifempty,
iferror,
ifna,
includes,
index,
index2col,
index2row,
int,
isArray,
isBlank,
isBool,
isBoolean,
isDate,
isEmail,
isEmpty,
isError,
isEven,
isFunction,
isInteger,
isLeapYear,
isNA,
isNumber,
isOdd,
isRef,
isText,
isWholeNumber,
isarray,
isblank,
isbool,
isboolean,
isdate,
isemail,
isempty,
iserror,
iseven,
isfalsy,
isfunction,
isleapyear,
isna,
isnumber,
isoWeekNum,
isodd,
isoweeknum,
isref,
istext,
istruthy,
isurl,
iswholenumber,
join,
left,
len,
lookup,
lower,
lt,
lte,
map,
match,
max,
min,
minute,
month,
multiply,
n,
ne,
not,
now,
nper,
npv,
numberValue,
numbers,
numbervalue,
oct2dec,
or,
parseBool,
parseDate,
parseQuery,
parsebool,
parsedate,
parsequery,
pi,
pluck,
pmt,
power,
proper,
pv,
query,
reduce,
ref,
replace,
rept,
right,
round,
roundup,
search,
second,
select,
serial,
sin,
some,
sort,
split,
substitute,
substituteAll,
subtract,
sum,
surroundKeys,
tan,
tau,
template,
text,
time,
timevalue,
today,
trim,
trunc,
unique,
upper,
vlookup,
xor,
year,
yearfrac,
}


IBM reveals three Cloud Pak for Security capabilities
On Wednesday, 20 November 2019, IBM launched Cloud Pak for Security – featuring industry-first innovations to connect with any security tool, cloud or on-premise system, without moving data from its source. The platform is said to include open-source technology for hunting threats, automation capabilities to help speed response to cyberattacks, and the ability to run in any environment.
According to IBM, Cloud Pak for Security is the first platform to leverage open-source technology, which can search and translate security data from a variety of sources, bringing together critical security insights from across a company’s multicloud IT environment.
As businesses move further into cloud maturity, applications and data are spread across multiple private and public clouds and on-premise resources. Attempts to protect this fragmented IT environment require security teams to undertake complex integrations and continuously switch between different screens and point products.
Here are three capabilities of Cloud Pak for Security:
1· Gain security insights without moving data. Transferring data to analyze it creates additional complexity. IBM Cloud Pak for Security can connect all data sources to uncover hidden threats and make better risk-based decisions while leaving the data where it resides.
2· Respond faster to security incidents with automation – IBM Cloud Pak for Security connects security workflows with a unified interface and automation playbooks so that teams can respond faster to security incidents.
3· Run anywhere. Connect security openly – IBM Cloud Pak for Security installs easily in any environment. It provides a unified interface to simplify operations.
“As businesses move mission-critical workloads to hybrid multicloud environments, security data is spread across different tools, clouds and IT infrastructure. This creates gaps that allow threats to be missed, requiring security teams to build and maintain costly, complex integrations and manual response plans,” says Mary O’Brien, GM of IBM Security. “With Cloud Pak for Security, we’re laying the foundation for a more connected security ecosystem designed for the hybrid, multicloud world.”
Edited by Jenna Delport
Follow Jenna Delport on Twitter
Follow IT News Africa on Twitter


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Class Summary | |
|---|---|
| Anaphor | Created with IntelliJ IDEA. |
| EntityTypes | Created by piek on 5/17/14. |
| EventTypes | Created by piek on 9/19/14. |
| FilterCorefSets | Created with IntelliJ IDEA. |
| LabelCount | Created by piek on 1/16/14. |
| ProcessNewsReaderCarBatch | Created by kyoto on 12/13/13. |
| ProcessNewsReaderFolderBatch | Created by kyoto on 12/13/13. |
| ProcessNewsReaderTechCrunchBatch | Created by kyoto on 12/13/13. |
| ProcessSeparateNafFilesBatch | Created by piek on 2/12/14. |
| ReadSourceMetaFile | Created by piek on 2/5/14. |
| RoleLabels | Created by piek on 5/11/14. |
| SemUtilObject | Created by piek on 1/3/14. |
| SplitTechCrunch | Created by piek on 2/11/14. |
| Statistics | Created by piek on 1/4/14. |
| Statistics.TotalStats | |
| TimeLanguage | Created by piek on 5/11/14. |
| Util | Created with IntelliJ IDEA. |
| Util.AppendableObjectOutputStream | Required to be able to write Composite SemEvent Objects to existing object files |
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


When a question is asked I want to be able to easily select and send a link to an answer located in a single HTML page. The answer should also be visible with JavaScript disabled.
Sometimes I use words as a way to express my frustration with human-computer interfaces. I apologize if this is offensive to you, and mean no harm.
Hey. Take it easy (Mp3 sound file). You can use this, too.


Vote.Gov Making voting smarter
Welcome to Vote.Gov!
We were tasked with increasing the voter turnout, while keeping our voting system as close to un-gameable as possible. Our focus on security and innovative new login process has allowed us to grant voters the privilege of voting from the comfort of their own homes. Gone are the days of the restricted voter.
Bacon ipsum dolor sit amet tongue reprehenderit filet mignon tri-tip, biltong meatball aliquip brisket leberkäse strip steak shankle aliqua. Ut qui tempor, non deserunt ex irure spare ribs quis consequat exercitation adipisicing. Magna salami voluptate, ball tip dolore cillum ribeye tongue do tri-tip.  Rump tenderloin eiusmod, ham capicola t-bone shankle occaecat. In cillum pig drumstick deserunt. Chicken adipisicing occaecat id, esse prosciutto velit in pork tri-tip commodo est beef ribs t-bone.
See some of our videos to learn more.
Or perhaps you would enjoy our photo gallery more?
Questions or concerns? Call us at 1-800-555-VOTE or email us at questions@vote.gov


WITNESS LIST Education Committee May 3, 2005 - 8:30A HB 25 FOR: Clark, Jeffrey Public Affairs Officer (Military Child Education Coalition), Harker Heights, TX Registering, but not testifying: For: Canaday, Jennifer Lobbyist (ATPE), Austin, TX Gustafson, Lindsay Staff Attorney (Texas Classroom Teachers Assoc.), Austin, TX SB 1120 FOR: Hutton, Gary W. Admin., Bexar Co. JJAEP; Admin., Bexar Co. Civil Dist. Judg (Bexar County Juvenile Board), San Antonio, TX ON: Canales, Ramiro Assistant Ed., Governmental Relations (Texas Association of School Administrators, Texas Association of School Boards), Austin, TX Capers, Lisa General Counsel (Texas Juvenile Probation Commission), Austin, TX Spriggs, Vicki Executive Director (TX Juvenile Probation Comm.), Austin, TX Registering, but not testifying: For: Velasquez, Sally Governmental Affairs Liaison (Texas Probation Association), Austin, TX SB 1248 FOR: Hutton, Gary W. Admin., Bexar Co. JJAEP; Admin., Bexar Co. Civil Dist. Judg (Bexar County Juvenile Board), San Antonio, TX Turner, Randy Director (Tarrant County Juvenile Services), Ft Worth, TX ON: Anderson, David General Counsel (Texas Education Agency), Austin, TX Brooke, Linda Director of Education Services (Texas Juvenile Probation Comm.), Austin, TX Registering, but not testifying: For: Medina, Estela P. President (Juvenile Justice Association of Texas), Austin, TX Velasquez, Sally Governmental Affairs Liaison (Texas Probation Association), Austin, TX


They were instrumental in raising the funds and building a state-of-the-art animal shelter in Ardmore, Oklahoma. Their tireless efforts to educate the public in the beneficial relationship animals can provide led them to helping form A New Leash on Life, Inc. We are forever grateful for their encouragement and support.
She has owned and operated Listen Up Pup canine training center the past forty years, where classes are offered to puppies and adult dogs on basic manners, agility, tricks, Canine Good Citizen, and reactive dog class. Listen Up Pup also offers a free behavior hotline to the community. Prior to starting A New Leash on Life, Inc., Barbara Lewis was the Oklahoma Field Instructor for a national Service Dog training agency for sixteen years. Barbara is a certified member of National Association of Dog Obedience Instructors and a Professional Member of Association of Pet Dog Trainers.
Brenda Spink serves as our Volunteer Coordinator, handling all inquiries and scheduling for Therapy Dog visits, and other activities of the volunteers. Brenda’s excellent organizational skills make her perfect for this job.
Geraldine Cummings enables future Service Dogs to be raised by volunteers until they are approximately fourteen months of age. During this time, Geraldine makes sure the volunteers have everything they need, and the pups are receiving necessary training. Having raised a Service Dog, Geraldine understands the needs of the volunteers.
Jonathan Cox completed our three-year apprentice training program, teaches dog training classes at Pontotoc Technical Center in Ada, and offers private instruction, boarding, and training as the owner of Buckaroos Retrievers & Retreats in Paul’s Valley. His experience in the boarding kennel business is an asset to the dogs he handles for our agency, and he serves as one of the instructors in both our classes and in our prison program.
Shelia Ford began as a Puppy Raiser and completed our three-year apprentice training program. Shelia’s involvement with her children’s activities gives her the opportunity to put the final-phase training for Service Dogs to the test of many distractions.
Michelle Traw began training dogs for Therapy Dog work. Her background as a teacher for special needs children helped in the development of our Therapy Dog training program.
We would like to thank all those who support us and make our work possible.


Notes for testers and developers
dataTableHeader
and dataTableCell
in order to display custom content. As stated in datatable documentation, this is out from the control of the datatable component. Hence if the developers use any of them, it's developer's responsibility to check and fix any accessibility issue. Specifically, in this case "Active" text lacks sufficient contrast with the current background color and the "Status" icons in the Active column do not have an accessible name. See the below snippet for a fix sample.

Yes
rowClick($event)
function. This is a function that is executed when the user clicks on the row. However, this functionality is not accessible, unless the user provides enough information regarding the triggering action consequences and implements an <input>
(like a <button>
or
) as part of the row that will allow to trigger the click via keyboard too.
rowDoubleClick($event)
function. This is a function that is executed when the user double-clicks on the row. However, this functionality is not accessible, unless the user provides enough information regarding the triggering action consequences and implements an <input>
(like a <button>
or
) as part of the row that will allow to trigger the click via keyboard too.


In this demo is demonstrated how to change the Custom Elements DropDown's animation.
Animation Type
None
Slide
Fade


RDPL55 Producer (256096 WTM bucks)
P
RDPL55
- Add RDPL55 to your Movie Fellows
- RDPL55 was last seen about 2 hours ago
RDPL55´s Gallery
RDPL55's DVD Shelf
RDPL55's Memorabilia
RDPL55's Quiz Stats
RDPL55 has solved 32266 Feature Films and 38878 Snapshots in total. RDPL55's Snapshots received an overall Rating of 7.10 and were favourited an average 1.61 times. RDPL55 has 58 SotDs.
Feature Film Score
- 233.(166)
13.92 %
insante - 234.(166)
13.92 %
Rohling - 235.(162)
13.9 %
RDPL55 - 236.(165)
13.84 %
stephan - 237.(165)
13.84 %
Jsky2


5/9 email to Chairs
I know that this process of budget cuts is taking place on a much tighter time frame than any of us would have hoped. I know that most of you were already working on scenarios for 10, 25, and 50% cuts in the adjunct budget following our briefing with P&B on April 23, and we all thought we would have more time to adjust the staffing and curriculum than we do now. The breakdown in negotiation between CUNY and the PSC of an extension on the date for notification of appointments for adjuncts resulted in the accelerated timeline we are now working on. As you work towards resolving the budgets in each of your units, I wanted to provide a few suggestions and explanations to guide your deliberation and decision making process.
Carlos Serrano has provided each Dean with financial targets that show the dollar amounts that would correspond to a 35% cut within each school/division. The Deans have discretion to provide for variation within departments, but each school/division should aim to meet the specified targets for Fall 2020.
Although all of the reductions do not have to come from non-reappointments, I see no way that any school/division can meet the adjunct reduction targets without significant non-reappointments. One of the reasons these non-reappointment letters need to go out by the May 15 deadline rather than removing work from adjuncts at a later date is that the non-reappointment letters will qualify eligible adjuncts for unemployment benefits soon rather than later.
Although significant non-reappointments are expected, other modes of meeting the targets can include reductions in loads for adjuncts, combining sections, having larger sections taught by tenure-line faculty, reduction in non-contractual reassigned time for faculty, and cancellation of low enrollment classes. The cost of instruction data should be particularly useful for this part of the exercise.
A topic that has come up in discussions about financial planning this year has been rescinding of sabbaticals. I don’t think we can make a blanket ruling at this time that all faculty sabbaticals are postponed, but Deans and/or chairs should present this option to faculty scheduled for leaves in the fall. I have already heard of many faculty that were scheduled for sabbaticals that want to postpone them, particularly if their projects involved significant travel, and this policy should be considered as a way to staff sections made vacant by reductions in the adjunct budget.
A remaining uncertainty is the mode of instruction for the fall. Today Governor Cuomo extended the New York pause until June 7, and I do not see a scenario where we will be on campus in any extensive way in the fall. Therefore I believe you should consider online and possibly very limited hybrid modes of instruction in planning/revising your schedules for the fall.
The situation for the fall remains fluid. We hope to hear shortly about the mode of instruction, and there are a number of factors including the enrollment, guidance on the CARES act, and changes in the status of the state budget that will influence the campus’ financial picture. In the meantime, thanks for all the effort you are putting into the current adjustments.
Best
Michael


SSH-ADD(1) BSD General Commands Manual SSH-ADD(1) NAME ssh-add — adds private key identities to the authentication agent SYNOPSIS ssh-add [-cDdkLlXx] [-t life] [file ...] ssh-add -s pkcs11 ssh-add -e pkcs11 DESCRIPTION ssh-add adds private key identities to the authentication agent, ssh-agent(1). When run without arguments, it adds the files ~/.ssh/id_rsa, ~/.ssh/id_dsa, ~/.ssh/id_ecdsa and ~/.ssh/identity. After loading a pri‐ vate key, ssh-add will try to load corresponding certificate information from the filename obtained by appending -cert.pub to the name of the pri‐ vate key file. Alternative file names can be given on the command line. If any file requires a passphrase, ssh-add asks for the passphrase from the user. The passphrase is read from the user's tty. ssh-add retries the last passphrase if multiple identity files are given. The authentication agent must be running and the SSH_AUTH_SOCK environment variable must contain the name of its socket for ssh-add to work. Any keys recorded in the blacklist of known-compromised keys (see ssh-vulnkey(1)) will be refused. The options are as follows: -c Indicates that added identities should be subject to confirmation before being used for authentication. Confirmation is performed by the SSH_ASKPASS program mentioned below. Successful confirmation is signaled by a zero exit status from the SSH_ASKPASS program, rather than text entered into the requester. -D Deletes all identities from the agent. -d Instead of adding identities, removes identities from the agent. If ssh-add has been run without arguments, the keys for the default identities will be removed. Otherwise, the argument list will be interpreted as a list of paths to public key files and matching keys will be removed from the agent. If no public key is found at a given path, ssh-add will append .pub and retry. -e pkcs11 Remove keys provided by the PKCS#11 shared library pkcs11. -k When loading keys into the agent, load plain private keys only and skip certificates. -L Lists public key parameters of all identities currently represented by the agent. -l Lists fingerprints of all identities currently represented by the agent. -s pkcs11 Add keys provided by the PKCS#11 shared library pkcs11. -t life Set a maximum lifetime when adding identities to an agent. The lifetime may be specified in seconds or in a time format specified in sshd_config(5). -X Unlock the agent. -x Lock the agent with a password. ENVIRONMENT DISPLAY and SSH_ASKPASS If ssh-add needs a passphrase, it will read the passphrase from the current terminal if it was run from a terminal. If ssh-add does not have a terminal associated with it but DISPLAY and SSH_ASKPASS are set, it will execute the program specified by SSH_ASKPASS and open an X11 window to read the passphrase. This is particularly useful when calling ssh-add from a .xsession or related script. (Note that on some machines it may be necessary to redirect the input from /dev/null to make this work.) SSH_AUTH_SOCK Identifies the path of a UNIX-domain socket used to communicate with the agent. FILES ~/.ssh/identity Contains the protocol version 1 RSA authentication identity of the user. ~/.ssh/id_dsa Contains the protocol version 2 DSA authentication identity of the user. ~/.ssh/id_ecdsa Contains the protocol version 2 ECDSA authentication identity of the user. ~/.ssh/id_rsa Contains the protocol version 2 RSA authentication identity of the user. Identity files should not be readable by anyone but the user. Note that ssh-add ignores identity files if they are accessible by others. EXIT STATUS Exit status is 0 on success, 1 if the specified command fails, and 2 if ssh-add is unable to contact the authentication agent. SEE ALSO ssh(1), ssh-agent(1), ssh-keygen(1), ssh-vulnkey(1), sshd(8) AUTHORS OpenSSH is a derivative of the original and free ssh 1.2.12 release by Tatu Ylonen. Aaron Campbell, Bob Beck, Markus Friedl, Niels Provos, Theo de Raadt and Dug Song removed many bugs, re-added newer features and created OpenSSH. Markus Friedl contributed the support for SSH protocol versions 1.5 and 2.0. BSD October 8, 2016 BSD


We build high performance apps from the foundation up using the latest tools and technologies.
No app is complete without dynamic content that converts. From in-app strategy to persuasive push notifications, we provide the prose that maximizes user engagement.
63% of apps are discovered through search. Using ASO techniques, we work with you to ensure your app gets the eyeballs, traffic, and downloads it deserves.
Lead Developer
I'm an engineer with an eye for design and a passion for creating captivating user experiences. I love sports, travel, technology, and craft beer. My experience includes work on more than a dozen iOS applications for both iPhone and iPad using almost every framework of the SDK. I've also worked with Android, OSX, and Ruby applications in personal and professional projects.
Content/Marketing Specialist
With senior level experience in the tech world, I've well-versed in the nuances of content curation and mobile marketing. I'm passionate about community-centric products and content strategy. To date, I've worked at multiple startups in San Francisco, from an early stage content curation website and the world’s largest social good platform to a midsize gaming studio and more. I’ve been there, launched this and rebranded that.


Class: ROM::Kafka::Connection::Consumer Private
- Inherits:
-
ROM::Kafka::Connection
- Object
- ROM::Kafka::Connection
- ROM::Kafka::Connection::Consumer
- Includes:
- Enumerable
- Defined in:
- lib/rom/kafka/connection/consumer.rb
Overview
This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.
The consumer-specific connection to Kafka cluster
It is wrapped around `Poseidon::Consumer` driver, and responsible for adopting poseidon API to ROM::Dataset via [#initializer] and [#each] methods.
ROM::Kafka consumer deals with tuples, hiding poseidon-specific implementation of fetched messages from the rest of the gem.
Constant Summary collapse
- DRIVER =
This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.
The 'poseidon'-specific class describing consumers
Poseidon::PartitionConsumer
Instance Attribute Summary collapse
-
#connection ⇒ ROM::Kafka::Connection::Consumer::DRIVER
readonly
private
Driver to Kafka.
Instance Method Summary collapse
-
#each {|tuple| ... } ⇒ Enumerator<Array<Hash{Symbol => String, Integer}>>
private
Iterates through Kafka messages.
-
#fetch ⇒ Array<Hash{Symbol => String, Integer}>
private
Fetches a single portion of messages and converts them to tuple.
-
#initialize(opts) ⇒ Consumer
constructor
private
Initializes a consumer connection.
Constructor Details
#initialize(opts) ⇒ Consumer
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Initializes a consumer connection
The initializer is attributes-agnostic. This means it doesn't validate attributes, but skips unused.
@todo: refactor usinng factory method Connection.build_consumer
59 60 61 62 63 64 |
# File 'lib/rom/kafka/connection/consumer.rb', line 59 def initialize(opts) super # takes declared attributes from options args = opts.values_at(:client_id, :brokers, :topic, :partition, :offset) @connection = DRIVER.consumer_for_partition(*args, attributes) @mutex = Mutex.new end |
Instance Attribute Details
#connection ⇒ ROM::Kafka::Connection::Consumer::DRIVER (readonly)
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Returns driver to Kafka.
32 33 34 |
# File 'lib/rom/kafka/connection/consumer.rb', line 32 def connection @connection end |
Instance Method Details
#each {|tuple| ... } ⇒ Enumerator<Array<Hash{Symbol => String, Integer}>>
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Iterates through Kafka messages
Fetches the next portion of messages until no messages given
82 83 84 85 86 87 88 89 |
# File 'lib/rom/kafka/connection/consumer.rb', line 82 def each return to_enum unless block_given? loop do tuples = fetch break unless tuples.any? tuples.each { |tuple| yield(tuple) } end end |
#fetch ⇒ Array<Hash{Symbol => String, Integer}>
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
Fetches a single portion of messages and converts them to tuple
70 71 72 |
# File 'lib/rom/kafka/connection/consumer.rb', line 70 def fetch @mutex.synchronize { @connection.fetch }.map(&method(:tuple)) end |


Home
About
Works
Blogs
Contact
Aman Zishan
About
About Me
Project
Text
Extractor-2
.
0
View Project
Other works
View Projects
01
02
03
03


Stroke Risk Prediction
Home
About
Gender
Select
Male
Female
Other
Age
Hypertension
Select
Yes
No
Heart Disease
Select
Yes
No
Ever Married
Select
Yes
No
Work Type
Select
Government Job
Never worked
Private
Self Employed
Student
Residence Type
Select
Urban
Rural
Average Glucose Level
BMI (Body Mass Index)
Smoking Status
Select
Unknown
Formly smoked
Never smoked
Smoked regularly
Submit


Using Plugins
Plugins allow you to add additional functionality to the script. A plugin in one php file that is added to the extensions/plugins directory.
Once a plugin is uploaded to the proper directory it immediately becomes available to use and is called like a php function.
Each plugin should contain documentation that shows you exactly how it is used but on average it would be called like this:
<?php plugin_name(); ?>
If a plugin allows parameters then it can be called in one of two ways:
1. <?php plugin_name('one', 'two', 'three'); ?>
2. <?php plugin_name('opt=one&opt2=two&opt3=3'); ?>
The plugin instructions should cover which way it is called.


In Spring of 2013, 21 latina women in Washington County documented their neighborhood walking environments. Select points on the map to see their stories.
Brought to you by Adalente Mujeres & Oregon Walks.


Folding in half
Folding paper in half is simple. The following algorithm may be used:
- Place the paper onto a flat surface, such as a table or counter.
- Firmly grasp two corners of the page which are on the same edge of the page (i.e. not diagonal corners).
- Gently these two corners to the opposing corners on the other side of the page.
- Ensure each corner is matched as closely as possible with the opposing corner, and then carefully flatten the page such that a crease forms halfway.
- Slide a fingernail against the fold to make the crease as crisp as possible.
Congratulations! The page is now folded in half.
Writing
One can write on a page using a pen or a pencil. There is no limit to the number of things which may be written; here are some example passages:
Example passages and code are included in code blocks like this one.
The quick brown fox jumped over the lazy dog.
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
#include <stdio.h>
int main(void) {
printf("Hello, world!\n");
return 0;
}
It is possible to make many wonderful things with only pen and paper. One could write a book, or formulate a mathematical proof! All that is required is a little creativity.
Printing
Just like a person, a computer can use a special device, called a printer, to put ink to paper. Here are some of the steps:
- Put paper into the printer.
- Turn the printer and computer on.
- Print a document using software on the computer.
Additionally,if you were to print the above C code (repeated below) using a printer, it would look much neater!
#include <stdio.h>
int main(void) {
printf("Hello, world!\n");
return 0;
}
A computer and a printer can write text or images far more quickly than a person can; the difference is appreciable for any document longer than a sticky note.
Airplaning
With the help of some elaborate folding techniques (see Folding above), a sheet of paper may be transformed into an airplane! To achieve this, simply:
- Get a piece of paper.
- Fold it into a paper airplane.
Armed with this knowledge, you'll be making delightful children's toys in no time.
Cutting
Another useful technique for altering the shape of a piece of paper is cutting. For this task, scissors are recommended, although a knife may also be used.
- Grab some paper and a pair of scissors.
- Place the sheet of paper between the two blades of the scissors.
- Squeeze the scissors handles together to shear the paper, cutting it.
A piece of paper that has been cut has several uses, such as being two smaller pieces of paper.


Slides available at: http://bit.ly/CnCMYR
| If you want to... | Then Use... |
| To View & Test Code | Chrome Dev Tools |
| Maximize Your Control | Command Line |
| Manage Versions of Your Code | Git (and GitHub) |
| Write Your Code | Sublime Text |
| Add Style to Your Code | Sass* |
| Add Interactivity To Your Site | jQuery* |
*HTML, Stylesheets (CSS), jQuery libraries, and CSS Compiler code are all written in Sublime Text, and connect to the HTML page via specific tags.

<!DOCTYPE html>

<meta name="name of your page" author="yourname">
<title>Browser tab title here </title>

This is your heading.

Visible page content appears between body tags.

<!DOCTYPE html>

<link type="text/css" rel="stylesheet" href="stylesheet.css"/>
<title>Page Title</title>

heading content

Some Content here

Image Credit:
LearnWebCode.com| Javascript | jQuery |
| Why Write From Scratch... | When the Tool is Already Built? |
Just as the <link> tag in the html page connects your CSS, a

If your script file depends on another script file (as our script file depends jQuery), the dependancy has to be loaded prior to the script that depends on it so in our case the jQuery script tag has to come before our script tag.
Event - a user-initiated activity such as mouse click, hovering over an area, or a keystroke
Understanding how command line works makes Git commands easier to get used to, and
not all programs have GUI interfaces!
Option 1: Personal Site - HTML/CSS
#LadyDevs
#KCWiT
#CodingAndCocktailsKC


--- layout: post title: How to configure Sublime Text 3 for Rubocop and Ruby coding standards categories: - articles tags: - Sublime Text - ruby on rails - Rubocop - Standards - PSR - PHP published: true ---
As far as standards go PHP has PSR, python has PEP and Ruby has..? Well, ruby doesn't really have an established best practices and standards document like the other two languages. Luckily, we do have two excellent coding guides and a gem little called Rubocop that help fill the gap.
Thanks to the awesome work of Bozhidar Batsov and many talented folks, we have an unofficial Ruby and Rails coding standards documentation. These are great resources for when you have questions concerning object oriented programming design challenges. Additionally, they also built the super useful Rubocop gem for automating style checks.
I suggest that you read through, or at least skim through, some of the suggested standards. These were created by some of the top people in the industry and are really great for becoming a Ruby master. Some of the standards proposed can be directly translated into a Sublime Text configuration file which we will now begin to build.
Image property of http://www.telegraph.co.uk/
Since, most developers are more or less polyglot's when it comes to programming languages, separating our different coding standards becomes a must. Fortunately, for us Sublime Text 3 has a nifty feature for creating syntax specific user configuration files.
Under the preferences menu in the Settings - More menu you will see the option for Syntax Specific user configuration. By selecting this option Sublime Text will take your currently active file's code syntax and create a config file specific to it (e.g. JSON.sublime-settings). This file will then only be applicable to files that are also using this language syntax.
Create the ruby specific user configuration by clicking the Syntax Specific - User option and then renaming the file to Ruby.sublime-settings
. Once created we can now start following the proposed Ruby style guide.
Image property of http://www.salon.com/
This section includes the cherry-picked settings that can be configured in your Ruby.sublime-settings
file. These will help bring your coding environment one step closer to being a highly efficient and up to standards workflow.
Using the UTF-8 file encoding is pretty much a standard for most files.
{% highlight json %} { "default_encoding": "UTF-8", } {% endhighlight %}Like I mentioned in my other article, How to configure Sublime Text for PSR Standards, utilizing unix line endings helps to keep all developers on the same page when using version control.
{% highlight json %} { "default_line_ending": "unix" } {% endhighlight %}By setting the ruler to 80 and word wrap to true, we can impose a soft limit of 80 characters on a file.
{% highlight json %} { "rulers": [ 80 ], "word_wrap": "true" } {% endhighlight %}Enough said.
{% highlight json %} { "ensure_newline_at_eof_on_save": true } {% endhighlight %}Unlike the PHP world of 4 spaces, Ruby developers generally use 2 spaces for indentation. I find this leads to more compact and readable code.
{% highlight json %} { "tab_size": 2, "translate_tabs_to_spaces": true } {% endhighlight %}Another setting that teams of developers will all need to use to avoid git conflicts. Kill the whitespace!
{% highlight json %} { "trim_trailing_white_space_on_save": true } {% endhighlight %}I've listed the completed Ruby.sublime-settings
file for easy copy-pasting. Enjoy.
The Ruby style guide has many more standards and best practices contained within it. Some of which we won't be able to configure via a simple settings file. Good thing we have the awesome gem Rubocop to tell us how to fix our code.
Image property of http://geektyrant.com/news/top-10-movie-quotes-from-robocop
In addition to the standards documents, the team behind them also created the Rubocop gem. Rubocop is like the ruby linter on steroids as it churns through your code unapologetically telling you what needs to be fixed according to the unofficial coding standards. Similiar to PHP's PSR-fixer, Rubocop can be setup to run in the background or manually at your leisure.
In order to start using Rubocop on your projects, first you need to install the gem with gem install rubocop
. Once installed, I prefer to use the Sublimelinter-rubocop
Sublime package to handle running Rubocop in the background. As per usual install it via Sublime's package manager system. Finally, with both the gem and package ready to go, add a file called .rubocop.yml
in the root directory of your project. It should contain the following code.
This tells Rubocop to in addition to running the regular Ruby style cops (syntax checkers) to also run the Rails cops as well. You can find additional documentation on Sublimelinter-rubocop here and Rubocop itself documentation here.
Image property of http://images.fandango.com/images/fandangoblog/
All Robocop quotes aside, by using the above setup you can prevent some of the common syntax pitfalls with Ruby. In addition to the automated setup reading the two unofficial guides can be a lifesaver in determining what method to use or how to structure an application.
Was there an additional setting I missed? How about another tool or gem you use to help you follow standards? Maybe a completely different standard? I would love to hear about them in a comment below. Justice has been served.


Nick's Development Work
Ruby on Rails, Python, PHP, JavaScript, AngularJS, HTML, CSS, etc...
The Feedr Project
Feedr is a dynamic news feed API resource that gathers the best stories from Mashable, Reddit, and Digg.
Give it a try!
Open Movie API Database
Utilizing the Open Movie Database API, this app will fetch a variety of different information about any movie you care to enter. In addition to AngularJS, this app also uses Bootstrap for styling and Animate.css for some snazzy effects.
Go ahead, type your favorite movie into the demo!
MLB Pythagorean Calculator
Pythagorean expectation is a formula invented by Bill James to estimate how many games a baseball team 'should' have won based on the number of runs they scored and allowed.
Built in AngularJS and Bootstrap.
Open Weather API
Using Open Weather API data, this app displays real-time weather information as well as a pic of the location from Flickr.
Type your favorite location in the Live Demo!
Discussion Forum
Using JavaScript on the frontend along with a Firebase data host on the backend, this app demonstrates real-time communication attributes.
List Maker
This dynamic app utilizes JavaScript to create this nifty To-Do List Maker.
Simply add items to the list and double click archived items to delete.


Known Issues and To-Do Plans
We believe that the released version of Soaplab2 is functional. But we
also know about many yet-to-be-implemented issues.
They are casually listed mixed together with the plans and suggestions
in the NOTES file. One day, they either
disappear (because they all will be solved), or I will format them
more properly .
There is also a casual document listing issues that we are not sure if
they should be solved or forgotten - see the DISCUSSION.
Last but not least, there is a casual list of issues and plans with Spinet Web
client.
We will also try to keep track about the discovered bugs in the SourceForge Bug
Report system. Please send your bugs preferably there.
However, it is good to have the major issues listed here:
Major known issues
- More complex Gowlab services (those
requiring additional XSLT transformation of results) are not yet
supported. Also the Gowlab documentation is not written yet.
- The Soaplab2 notification protocols are not fully implemented
(the client-poll works fully, but not the
server-push).
- Storing results in a relational database.
Major plans for future
- Fully Java-pure converter/parser of the metadata ACD files to
XML files.
- A GUI (a working name is Soaplab Dashboard) for
helping Soaplab service providers to create metadata files, deploy and
monitor their services.
Last modified: Tue Feb 5 01:27:56 2008


Provide us with some information about your daily water consumption, then hit enter.
{{advice}}
Your input will be stored and processed to help improve our service.
Come support Aquatify on GitHub
© 2020 Aquatify.cc | All rights reserved.


Triad’s secureASIC is a proprietary solution and designed unique for your product. Triad manages a supply chain to your specification:
With a secureASIC, Triad will work with your to ensure that your security solution will stay in production as long as you need. With total control over the supply chain, you will no longer be at the mercy of your silicon vendors plans for EOL!
Other standard products exist in the market but none are as flexible as a Triad secureASIC. Start to define and develop a secureASIC with Triad today and protect your revenue stream.


HOME
SERVICES
ABOUT
CONTACT US
We are developing this content
as quickly as humanly possible.
For dev or analytics inquiries in
the meantime, get in touch at:
<EMAIL_ADDRESS>Stay tuned!


Bully Blocking is a tool that protects you from online harassment.
Copyright © 2017 Arman Mousavi, Kaysha Chandran, Rishi Dutta, Sam Jain


Steps:
a) Enter Player Names (Player 1 Vetoes First)
b) Click 2 Categories for Vetoes
c) Click 1st Category to Race
d) Click Won/Lost based on the result for the Selector of the Category
e) Click 2nd Category to Race
f) Click Won/Lost based on the result for the Selector of the Category
g) Click Random to pick 3rd Category to Race
h) Click "P1 Won" or "P2 Won" based on the winner of the Race
a) Enter Player Names (Player 1 Vetoes First)
b) Click 2 Categories for Vetoes
c) Click 1st Category to Race
d) Click Won/Lost based on the result for the Selector of the Category
e) Click 2nd Category to Race
f) Click Won/Lost based on the result for the Selector of the Category
g) Click Random to pick 3rd Category to Race
h) Click "P1 Won" or "P2 Won" based on the winner of the Race


My Patients
Search:
[clear]
Add To Network
Create New Patient
Patient Name (Age)
City
Location
Last Appointment
Emr
Connect
{{record.patientname}} ({{record.age}})
{{record.city_c}}
{{record.location_c}}
{{record.date}}
View/Edit Emr
Connect Now
No Records Found
Connect Now
Select incidence name for the appointment e.g.
Diabetes, Hypertension, Asthma, Glaucoma,
etc.
New Incidence
Select Profile
{{template[0]}}
Old Incidence
Previous Incident
Patient Details
First Name * :
Middle Name :
Last Name * :
Date Of Birth* :
Mobile No :
Email :
Users listed below have the same registration information. Do you want to register another user ?
Patient registered successfully
Okay
Add to Network
IOH ID*
Email ID*


Brand
Home
Collections
Magazine
Shop
Hortensia
Divide pasta among bolws. Top with more
Parmesan and remaining pistachios.


March 13th 2018
Please note you can now swap your old tokens for new tokens at Zapple. Click here for more information.
December 18th 2017
SIFT can require significantly more gas than other tokens to send - especially if being transferred to an address that holds no SIFT or if all SIFT from a wallet is being transferred. SIFT-holders voted whether or not to redeploy the contract to change this and it was decided to keep the status quo. The technical background can be found in SVP001 whilst the voting results are here.
The biggest problem that SIFT-holders find with this is when attempting to withdraw SIFT from EtherDelta. It is important that token-holders are aware of the difference between gas limits and gas price to prevent wasting money. Gas price defines how quickly a transaction can happen. The EthGasStation website shows how quickly transactions complete for various costs. As transferring SIFT is rarely a time-sensitive transaction the "Safe Low" price can be used - which may be as low as 0.1gwei. The gas limit says how much gas a transaction can use. This is what has to be increased for SIFT transactions. A transaction will only fail due to a low gas limit - it will just be slow with a low gas price.
SIFT recommends the following gas limit values. We always recommend using the safe low value from EthGasStation.
| Sender | Recipient | Gas Limit |
| Sends all SIFT | Has no SIFT | 4,000,000 |
| Sends all SIFT | Has some SIFT | 3,200,000 |
| Sends some SIFT | Has no SIFT | 700,000 |
| Sends some SIFT | Has some SIFT | 50,000 |
The following steps should allow you to withdraw from EtherDelta to a wallet not having SIFT on it or deposit all SIFT if you want to sell it on EtherDelta. You need in both cases a larger gas limit than the EtherDelta standard.
EtherDelta does not support setting the gas price directly. The best option for this is to use MyEtherWallet.com to directly access the EtherDelta smart contract to withdraw your SIFT. You can use MyEtherWallet if you have a Trezor, private key, Ledger or recovery seed. You must use the same wallet on MyEtherWallet.com that holds SIFT on EtherDelta – for example if you authenticate at EtherDelta using a private key, enter that key in step 9 below.
Once you have your wallet to deposit SIFT in to follow these instructions. Please note your wallet will need enough ETH to cover the gas cost. At 0.5 gwei and 3,000,000 of gas used that will be 0.0015 ETH. Likewise if you decide you want a much quicker transaction and want to pay 21 gwei for gas you would need 0.063 ETH. With 50 gwei recommended in congested network it starts to get expensive to move all sift 0.15 ETH. You can take a look for the "SafeLow" gas price to get transactions through at https://ethgasstation.info/
Once you’ve made your first SIFT withdrawal from Etherdelta you can withdraw again to the same wallet relatively easily to withdraw further SIFT to. The gas price drops to 60k withdrawing some SIFT from EtherDelta to a wallet that already holds it and therefore it becomes possible to just use the EtherDelta interface for future withdrawals.


--- layout: post title: "F# free monad recipe" description: "How to create free monads in F#." date: 2017-08-07 08:11 UTC tags: [Software Design, Dependency Injection, F#, Functional Programming] image: "/content/binary/decision-flowchart-for-free-monads.png" image_alt: "Decision flowchart for whether or not to choose free monads as a design principle." --- {% include JB/setup %}
{{ page.description }}
This is not a design pattern, but it's something related. Let's call it a recipe. A design pattern should, in my opinion, be fairly language-agnostic (although hardly universally applicable). This article, on the contrary, specifically addresses a problem in F#:
How do you create a free monad in F#?
By following the present recipe.
The recipe here is a step-by-step process, but be sure to first read the sections on motivation and when to use it. A free monads isn't a goal in itself.
This article doesn't attempt to explain the details of free monads, but instead serve as a reference. For an introduction to free monads, I think my article Pure times is a good place to start. See also the Motivating examples section, below.
A frequently asked question about F# is: what's the F# equivalent to an interface? There's no single answer to this question, because, as always, It Depends™. Why do you need an interface in the first place? What is its intended use?
Sometimes, in OOP, an interface can be used for a Strategy. This enables you to dynamically replace or select between different (sub)algorithms at run-time. If the algorithm is pure, then an idiomatic F# equivalent would be a function.
At other times, though, the person asking the question has Dependency Injection in mind. In OOP, dependencies are often modelled as interfaces with several members. Such dependencies are systematically impure, and thereby not part of functional design. If at all possible, prefer impure/pure/impure sandwiches over interactions. Sometimes, however, you'll need something that works like an interface or abstract base class. Free monads can address such situations.
In general, a free monad allows you to build a monad from any functor, but why would you want to do that? The most common reason I've encountered is exactly in order to model impure interactions in a pure manner; in other words: Dependency Injection.
This recipe comes in three parts:
Imagine that you have an interface that you'd like to refactor. In C# it might look like this:
public interface IFace { Out1 Member1(In1 input); Out2 Member2(In2 input); }
In F#, it'd look like this:
type IFace = abstract member Member1 : input:In1 -> Out1 abstract member Member2 : input:In2 -> Out2
I've deliberately kept the interface vague and abstract in order to showcase the recipe instead of a particular example. For realistic examples, refer to the examples section, further down.
To refactor such an interface to a functor, do the following:
map
in order to prevent naming conflicts. I usually name this function mapI
, where the I stands for instruction.'a -> 'b
as its first (curried) argument, and a value of the union type as its second argument. It should return a value of the union type, but with the generic type argument changed from 'a
to 'b
.
type FaceInstruction<'a> = | Member1 of (In1 * (Out1 -> 'a)) | Member2 of (In2 * (Out2 -> 'a))
The map function becomes:
// ('a -> 'b) -> FaceInstruction<'a> -> FaceInstruction<'b> let private mapI f = function | Member1 (x, next) -> Member1 (x, next >> f) | Member2 (x, next) -> Member2 (x, next >> f)
Such a combination of union type and map function satisfies the functor laws, so that's how you refactor an interface to a functor.
Given any functor, you can create a monad. The monad will be a new type that contains the functor; you will not be turning the functor itself into a monad. (Some functors can be turned into monads themselves, but if that's the case, you don't need to create a free monad.)
The recipe for turning any functor into a monad is as follows:
Free
and Pure
.Free
case should contain a single value of the contained functor, generically typed to the 'program' union type itself. This is a recursive type definition.Pure
case should contain a single value of the union's generic type.bind
function for the new union type. The function should take two arguments:bind
function should be a function that takes the generic type argument as input, and returns a value of the 'program' union type as output. In the rest of this recipe, this function is called f
.bind
function should be a 'program' union type value.bind
function should be a 'program' union type value, with the same generic type as the return type of the first argument (f
).bind
function as recursive by adding the rec
keyword.bind
function by pattern-matching on the Free
and Pure
cases:Free
case, pipe the contained functor value to the functor's map function, using bind f
as the mapper function; then pipe the result of that to Free
.Pure
case, return f x
, where x
is the value contained in the Pure
case.bind
for Bind
and Pure
for Return
.
type FaceProgram<'a> = | Free of FaceInstruction<FaceProgram<'a>> | Pure of 'a
It's worth noting that the Pure
case always looks like that. While it doesn't take much effort to write it, you could copy and paste it from another free monad, and no changes would be required.
According to the recipe, the bind
function should be implemented like this:
// ('a -> FaceProgram<'b>) -> FaceProgram<'a> -> FaceProgram<'b> let rec bind f = function | Free x -> x |> mapI (bind f) |> Free | Pure x -> f x
Apart from one small detail, the bind
function always looks like that, so you can often copy and paste it from here and use it in your code, if you will. The only variation is that the underlying functor's map function isn't guaranteed to be called mapI
- but if it is, you can use the above bind
function as is. No modifications will be necessary.
In F#, a monad is rarely a goal in itself, but once you have a monad, you can add a computation expression builder:
type FaceBuilder () = member this.Bind (x, f) = bind f x member this.Return x = Pure x member this.ReturnFrom x = x member this.Zero () = Pure ()
While you could add more members (such as Combine
, For
, TryFinally
, and so on), I find that usually, those four methods are all I need.
Create an instance of the builder object, and you can start writing computation expressions:
let face = FaceBuilder ()
Finally, as an optional step, if you've refactored an interface to an instruction set, you can add convenience functions that lift each instruction case to the free monad type:
Free
case. The case constructor must be invoked with the pair of data it requires. Populate the first element with values from the input arguments to the convenience function. The second element should be the Pure
case constructor, passed as a function.FaceInstruction<'a>
:
// In1 -> FaceProgram<Out1> let member1 in1 = Free (Member1 (in1, Pure)) // In2 -> FaceProgram<Out2> let member2 in2 = Free (Member2 (in2, Pure))
Such functions are conveniences that make it easier to express what the underlying functor expresses, but in the context of the free monad.
A free monad is a recursive type, and values are trees. The leafs are the Pure
values. Often (if not always), the point of a free monad is to evaluate the tree in order to pull the leaf values out of it. In order to do that, you must add an interpreter. This is a function that recursively pattern-matches over the free monad value until it encounters a Pure
case.
At least in the case where you've refactored an interface to a functor, writing an interpreter also follows a recipe. This is equivalent to writing a concrete class that implements an interface.
interpret
. Make it recursive by adding the rec
keyword.Pure
and each case contained in Free
.Pure
case, simply return the value contained in the case.Free
case, pattern-match the underlying pair out if each of the instruction-set functor's cases. The first element of that tuple is the 'input value'. Pipe that value to the corresponding implementation function, pipe the return value of that to the function contained in the second element of the tuple, and pipe the result of that recursively to the interpreter function.imp1
and imp2
exist. According to the recipe, imp1
has the type In1 -> Out1
, and imp2
has the type In2 -> Out2
. Given these functions, the running example becomes:
// FaceProgram<'a> -> 'a let rec interpret = function | Pure x -> x | Free (Member1 (x, next)) -> x |> imp1 |> next |> interpret | Free (Member2 (x, next)) -> x |> imp2 |> next |> interpret
The Pure
case always looks like that. Each of the Free
cases use a different implementation function, but apart from that, they are, as you can tell, the spitting image of each other.
Interpreters like this are often impure because the implementation functions are impure. Nothing prevents you from defining pure interpreters, although they often have limited use. They do have their place in unit testing, though.
// Out1 -> Out2 -> FaceProgram<'a> -> 'a let rec interpretStub out1 out2 = function | Pure x -> x | Free (Member1 (_, next)) -> out1 |> next |> interpretStub out1 out2 | Free (Member2 (_, next)) -> out2 |> next |> interpretStub out1 out2
This interpreter effectively ignores the input value contained within each Free
case, and instead uses the pure values out1
and out2
. This is essentially a Stub - an 'implementation' that always returns pre-defined values.
The point is that you can have more than a single interpreter, pure or impure, just like you can have more than one implementation of an interface.
Free monads are often used instead of Dependency Injection. Note, however, that while the free monad values themselves are pure, they imply impure behaviour. In my opinion, the main benefit of pure code is that, as a code reader and maintainer, I don't have to worry about side-effects if I know that the code is pure. With a free monad, I do have to worry about side-effects, because, although the ASTs are pure, an impure interpreter will cause side-effects to happen. At least, however, the side-effects are known; they're restricted to a small subset of operations. Haskell enforces this distinction, but F# doesn't. The question, then, is how valuable you find this sort of design.
I think it still has some value, because a free monad explicitly communicates an intent of doing something impure. This intent becomes encoded in the types in your code base, there for all to see. Just as I prefer that functions return 'a option
values if they may fail to produce a value, I like that I can tell from a function's return type that a delimited set of impure operations may result.
Clearly, creating free monads in F# requires some boilerplate code. I hope that this article has demonstrated that writing that boilerplate code isn't difficult - just follow the recipe. You almost don't have to think. Since a monad is a universal abstraction, once you've written the code, it's unlikely that you'll need to deal with it much in the future. After all, mathematical abstractions don't change.
Perhaps a more significant concern is how familiar free monads are to developers of a particular code base. Depending on your position, you could argue that free monads come with high cognitive overhead, or that they specifically lower the cognitive overhead.
Insights are obscure until you grasp them; after that, they become clear.
This applies to free monads as well. You have to put effort into understanding them, but once you do, you realise that they are more than a pattern. They are universal abstractions, governed by laws. Once you grok free monads, their cognitive load wane.
Consider, then, the developers who will be interacting with the free monad. If they already know free monads, or have enough of a grasp of monads that this might be their next step, then using free monads could be beneficial. On the other hand, if most developers are new to F# or functional programming, free monads should probably be avoided for the time being.
This flowchart summarises the above reflections:
Your first consideration should be whether your context enables an impure/pure/impure sandwich. If so, there's no reason to make things more complicated than they have to be. To use Fred Brooks' terminology, this should go a long way to avoid accidental complexity.
If you can't avoid long-running, impure interactions, then consider whether purity, or strictly functional design, is important to you. F# is a multi-paradigmatic language, and it's perfectly possible to write code that's impure, yet still well-structured. You can use partial application as an idiomatic alternative to Dependency Injection.
If you prefer to keep your code functional and explicit, you may consider using free monads. In this case, I still think you should consider the maintainers of the code base in question. If everyone involved are comfortable with free monads, or willing to learn, then I believe it's a viable option. Otherwise, I'd recommend falling back to partial application, even though Dependency Injection makes everything impure.
The strongest motivation, I believe, for introducing free monads into a code base is to model long-running, impure interactions in a functional style.
Like most other software design considerations, the overall purpose of application architecture is to deal with (essential) complexity. Thus, any example must be complex enough to warrant the design. There's little point in a Dependency Injection hello world example in C#. Likewise, a hello world example using free monads hardly seems justified. For that reason, examples are provided in separate articles.
A good place to start, I believe, is with the small Pure times article series. These articles show how to address a particular, authentic problem using strictly functional programming. The focus of these articles is on problem-solving, so they sometimes omit detailed explanations in order to keep the narrative moving.
If you need detailed explanations about all elements of free monads in F#, the present article series offers just that, particularly the Hello, pure command-line interaction article.
The above recipes describe the regular scenario. Variations are possible. Obviously, you can choose different naming strategies and so on, but I'm not going to cover this in greater detail.
There are, however, various degenerate cases that deserve a few words. An interaction may return no data, or take no input. In F#, you can always model the lack of data as unit
(()
), so it's definitely possible to define an instruction case like Foo of (unit * Out1 -> 'a)
, or Bar of (In2 * unit -> 'a)
, but since unit
doesn't contain any data, you can remove it without changing the abstraction.
The Hello, pure command-line interaction article contains a single type that exemplifies both degenerate cases. It defines this instruction set:
type CommandLineInstruction<'a> = | ReadLine of (string -> 'a) | WriteLine of string * 'a
The ReadLine
case takes no input, so instead of containing a pair of input and continuation, this case contains only the continuation function. Likewise, the WriteLine
case is also degenerate, but here, there's no output. This case does contain a pair, but the second element isn't a function, but a value.
This has some superficial consequences for the implementation of functor and monad functions. For example, the mapI
function becomes:
// ('a -> 'b) -> CommandLineInstruction<'a> -> CommandLineInstruction<'b> let private mapI f = function | ReadLine next -> ReadLine (next >> f) | WriteLine (x, next) -> WriteLine (x, next |> f)
Notice that in the ReadLine
case, there's no tuple on which to pattern-match. Instead, you can directly access next
.
In the WriteLine
case, the return value changes from function composition (next >> f
) to a regular function call (next |> f
, which is equivalent to f next
).
The lift functions also change:
// CommandLineProgram<string> let readLine = Free (ReadLine Pure) // string -> CommandLineProgram<unit> let writeLine s = Free (WriteLine (s, Pure ()))
Since there's no input, readLine
degenerates to a value, instead of a function. On the other hand, while writeLine
remains a function, you'll have to pass a value (Pure ()
) as the second element of the pair, instead of the regular function (Pure
).
Apart from such minor changes, the omission of unit
values for input or output has little significance.
Another variation from the above recipe that you may see relates to interpreters. In the above recipe, I described how, for each instruction, you should create an implementation function. Sometimes, however, that function is only a few lines of code. When that happens, I occasionally inline the function directly in the interpreter. Once more, the CommandLineProgram
API provides an example:
// CommandLineProgram<'a> -> 'a let rec interpret = function | Pure x -> x | Free (ReadLine next) -> Console.ReadLine () |> next |> interpret | Free (WriteLine (s, next)) -> Console.WriteLine s next |> interpret
Here, no custom implementation functions are required, because Console.ReadLine
and Console.WriteLine
already exist and serve the desired purpose.
This article describes a repeatable, and automatable, process for refactoring an interface to a free monad. I've done this enough times now that I believe that this process is always possible, but I have no formal proof for this.
I also strongly suspect that the reverse process is possible. For any instruction set elevated to a free monad, I think you should be able to define an object-oriented interface. If this is true, then object-oriented interfaces and AST-based free monads are isomorphic.
Comments
Hello Mark. I am trying to understand what is going on.
So basically the Free Moand allows us to separate pure code from impure code even when the impure/pure/impure sandwish idea is not possible to implement. Right?
We want to separate pure and impure code for these reasons: (1) Easier testing (2) Reasoning about pure code is easier than impure code (3) making impure code explicit makes it easier to understand programs. Is this correct?
What I am still trying to figure out is why we can't simply do this with Dependency Injection?
We can separate all units of behavior into pure ones and impure ones (e.g. functions), and then compose them all in the Composition Root. Pure units take no dependencies, they take in "direct input" and give back "direct output" as you describe in one of your blog posts.
To make the impure code explicit and clear, we can make the root method in the Composition Root construct all impure units of behavior first (e.g. adapters to the external world) and then inject them into a method that bakes these dependencies with the rest of pure code. E.g.:
public static IApplication CreateApplication(IImpureDependency1 dependency1, IImpureDependency2 dependency2) => { //compose graph here}
If you have sub methods that the CreateApplication method uses for modularizing the Composition Root, they will also take any impurities they need as parameters.
So in summary, only the Composition Root knows about the impure parts of the application and they are explicitly stated as parameters in the Composition Root methods.
Doesn't this solve the impure/pure separation issue?
For example, to test, you can easilly call the CreateApplication method and pass the fake (pure) dependencies. This will make the whole graph pure in the test.
Also, the Composition Root would make it clear which impure dependencies each component in the system depends on.
Am I missing something?
Hello Yacoub, thank you for writing. Your summary of the motivations covers most of them. The reason that purity interests me is that it forces me (and everyone else) to consider decoupling. One day, I should write a more explicit article about this, but I believe that the general problem with programming today has little to do with writing code, but with reading it. Until I get such an article written, I can only refer to my Humane Code video, and perhaps my recent appearance on .NET Rocks!. What fundamentally interests me is how to break down code into small enough chunks that they fit in our brains at all levels of abstraction. Purity, and functional programming in general, attracts me because it offers a principled way of doing that.
If we forget about functional programming and free monads for a while, we could ask a question similar to yours about Dependency Injection (DI). Why should we use Dependency Injection? Can't we just, say, call a database when we need some data? Technically, we can, but we deliberately invert the control of our code so that it becomes easier to break apart into smaller chunks. You may find this observation trivial, but it wasn't ten years ago, and I made much effort in my book to explain the benefits of DI.
The problem with DI is that at detailed levels of abstractions, DI-based code may fit in our brains, but at higher levels of abstraction the complexity still increases. Put another way, understanding a single class that receives a few dependencies is easy. Getting a high-level, big-picture understanding of a DI-based code base can still be quite the challenge. At a high level of abstraction, the moving parts in underlying components are still too visible, you could say.
Strictly functional programming interests me because, by pushing impure behaviours to the boundaries of the application, the pure core of an application becomes easier to treat as a hierarchy of abstractions. (I really need to write an article with diagrams about this some day.)
What's strictly functional programming? It's code that obeys the rule that pure code can't call impure code. The reason I find Haskell so interesting is that the compiler enforces that rule. Code isn't pure if it calls impure functions, and in Haskell, the code simply will not compile if you attempt to do that.
F#, on the other hand, doesn't work like that. There's no compile-time check of whether the code is pure or impure. Thus, when you pass functions to other functions, your higher-order function could look pure, but since you don't know what an 'injected' function does, you really don't know if it's pure or not. In F#, all it takes is a single call to, say,
DateTime.Now
,Guid.NewGuid()
, or similar, deep in your system, and that makes the entire code base impure!The only way to prevent that in F# is by diligence.
That's a roundabout answer to your question. The gist of it, though, is that in F#, you rarely need free monads. If you find yourself in the situation where a free monad would be required in Haskell, you could just as well use DI, or rather, partial application. My article on that approach explains how this works in F#, but also why it doesn't work in Haskell. When you inject impure behaviour into an 'otherwise' pure function, then everything becomes impure.
This is where F# differs from Haskell. In Haskell, such an attempt simply doesn't compile. In F#, an otherwise pure function suddenly becomes impure. If you mostly care about that distinction because of, say, testability, then that's not a problem, because when you 'inject' pure behaviour, then the composed function is still pure, and thus trivial to unit test.
The entire system is still impure with that design, though, and that can make it difficult to fit the entire application behaviour in our brains.
I'm afraid this answer doesn't help. I'll have to write a more coherent article on this some day, but I wanted to leave this here because, realistically, a more coherent article isn't part of my immediate plans.
Hello Mark. Thanks for the reply and for providing the links. I have already watched your Humane Code videos at clean coders before. Will listen to the podcast too.
I understand that with the free monad, you can maintain the rule that pure code will never call impure code.
This is one goal.
However, as you describe, this by itself is not the final goal. We want to achieve this goal as a mean to achieve other goals. For example, we want our code to be easier to reason about.
As you describe, we cannot achieve the first goal using DI (or partial application). And in Haskell, the compiler will prevent us from even trying.
However, I think you agree with me that there is still some great value in separating "pure" and impure code in different functions or classes, and then combining them in the Composition Root. This is basically Command Query Separation + DI. Although the graph as a whole is impure, some benefit (e.g. easier to reason about code) is still there as a result of the separation.
What I am trying to argue (or let me say think about and discuss) is that if one does the following:
- Separate impure and pure behavior at the level of individual units of behavior (e.g. functions or classes).
- Compose these units at the Composition Root (only the Composition Root knows about the impure units).
- In the Composition Root, first all impure units are created/prepared, and then injected into "pure" (now not pure) units.
- Make impure dependencies explicit as parameters in the "Create" methods of the Composition Root. (Basically "Create" methods are a way to modularize the Composition Root. I describe what I mean in more details here
then there is not much value in moving from what I just described to using Free monads just to make the Haskell compiler happy :).Or is there something that I am missing?
Basically, if we forget for a moment about the first goal (since it is only a mean to other goals), what goals will we be not achieving?
In your reply, I can find the following that might answer these questions:
"Getting a high-level, big-picture understanding of a DI-based code base can still be quite the challenge. At a high level of abstraction, the moving parts in underlying components are still too visible"
But I can't understand what you mean here. What is the problem here? and how does the Free monad fix it?
I hope I was able to explain my ideas correctly.

Regarding CQS, this is not exactly the same as separating impure and pure code. Still, a query can be impure (like one that reads from the database). Such query can be separated into a set of pure and impure queries. Also, a command can have some pure logic in it that can be extracted into a separate pure query (or queries). But, CQS is a step in the right direction towards this and it is a good example of how separation at some level has benefits of its own.
I would like to explain also that the steps I describe in my comment aim basically to delay the composition of pure and impure code to the last possible moment. So basically, all pure logic is composed first (parameterized with functions/delegates/interfaces representing possibly impure code). After that, impure code will be injected into such pure graph rendering it impure of course.
So basically, imagine an imaginary version of Haskell that would allow the root method of an application to allow “pure” code to call impure code.
Here is a concrete example. Imagine these three pure functions:
(A, Func<C,D> dep1, Func<E,F> dep2) => B (1)
(C, Func<G,H> dep3) => D (2)
(G, Func<I,J> dep4) => H (3)
Now, in the Composition Root, we "compose" these together to get the following:
(A, Func<I,J> dep4, Func<E,F> dep2) =>B
So far, this is a pure function, we havn't injected any impurities in it. Thinking about this, this might be a special case of dependency injection. We might call it dependency replacing or something like that.
What I have done is "inject" function #2 as dep1 in function #1. But this is not fully injected. I replaced "dep1" with "dep3".
Then, I "inject" function #3 as dep3. Again, this is not full injection as I replace it with "dep4".
Now, after all "pure" functions have been baked together, I inject the impure "dep4" and "dep2" to get this:
A => B
I hope the code gets displayed correctly in the comment.
Yacoub, thank you for the pseudo-code. That makes it easier to discuss things.
Your premise is that functions 1, 2, and 3 are pure. The rest of the argument rests on whether or not they are. Just to be sure that we share the same terminology, I take pure to mean referentially transparent. Nothing you've written gives me any indication that this isn't your interpretation as well, so I mostly include this as an explicit definition for the benefit of other readers who may happen upon this discussion in the future.
It's clear that a function (or method) that adds two numbers together is pure. This also applies to any other first-order function with isolation. I use the word isolation as described by Jessica Kerr: A function has the property of isolation when the only information it has about the external word is passed into it via arguments.
You can write arbitrarily complex isolated functions in, say, C#:
To be clear, this
Foo
method makes no sense, but it is, as far as I can tell, pure; it operates entirely on its input.Consider, however, this variation:
Notice that
DateTime.DaysInMonth(year, imonth)
replaces the hard-coded value28
. Is this variation pure?I don't know. In order to figure that out, we'd need to understand if
DateTime.DaysInMonth
is pure. Does it use a hard-coded table or algorithm of leap years, or does it use a call to the operating system (OS)? If the latter, does the OS base its functionality on a pure implementation, or does it look up the information in some resource (like the Windows Registry)?With leap years, and for the Gregorian calendar, a pure algorithm exists, but imagine that we create a similar nonsense function that creates
DateTimeOffset
values, including time and time-zone offsets. In this case, figuring out if a value is valid relies on external data, since rules about daylight saving time are political and subject to change.My point is that without a machine tool (such as a type system) to guide us, it's practically impossible to reason about the purity of code.
To make matters worse, as soon as you pass a function as an argument to another function, all bets are off. Even if you've diligently reviewed functions like 1, 2, and 3 above for purity, they're only pure if
dep2
anddep4
are pure as well.Haskell takes away all that angst related to purity by enforcing it via its type system. This liberates us to worry about other things, because the compiler has our backs regarding purity.
In C#, F#, Java, and most other languages, we get no such guarantees. As I've tried to demonstrate above, I'd regard all non-trivial code to be impure. All it takes is one system call,
Guid.NewGuid()
,random.Next()
,DateTime.Now
,log.Warning("foo")
, etc. to make all code transitively calling such a statement impure. This is, realistically, impossible to prevent.Do we care, then? What if the functions 1, 2, and 3 are 'pure enough'?
In an analogy to this discussion, in RESTful design,
GET
requests should be side-effect free. Almost all web servers, however, log HTTP requests, soGET
requests are never side-effect free. The interpretation used in that context, therefore, is thatGET
requests should be free of side effects for which the client is responsible.You can have a similar discussion about functional programming. What if a function logs debug information? Does that change the observable state of the system?
In any case, before even beginning to discuss whether dependency injection or partial application is functional, we need to make it clear why we care about purity.
I care about purity because it eliminates entire classes of bugs. It also means that I don't have to log what happens inside my pure code; as long as I log what happens at the impure boundary, I can always reproduce the result of a pure computation. All this makes the overall code simpler. Logging, caching, instrumentation. Many cross-cutting concerns either disappear or greatly simplify.
Returning to the overall discussion related to this article, free monads are one way to separate pure code from impure code. What you suggest, though, isn't pure, because all it takes to make the entire composition impure is that
dep2
ordep4
are impure (or one of the 'pure' functions turning out to be impure after all). It's Dependency Injection, only you replace interfaces with delegates.Does it matter? Probably not. Trying to keep things 'as pure as possible' in C# and similar languages could still provide benefits. That's how I approach F#. Ultimately, the goal is to make the code sustainable. If you can do that with Dependency Injection or partial application, then the mission is accomplished.
In Haskell, free monads are sometimes required, but in F#, it's a specialised design I'd only reach for in niche situations.


--- layout: archive title: Zulip Chat Archive permalink: /stream/116395-maths/topic/Implicit.20function.20theorem.html ---
I've just realized that I don't remember a lot of simple facts about infinite-dimensional Banach spaces. I'm trying to formulate a geometric version of the implicit function theorem. Currently we have a version that takes f : E × F → G
such that df/dy
is invertible and returns E × G → F
. I'd like to have a version that takes f : E → F
such that df
is surjective, and returns ker (df) × F → E
.
You'll probably hit Fredholm operators pretty soon.
The only issue is to identify E
with ker (df) × (E / ker df)
. Do I need extra assumptions?
@Patrick Massot I'm afraid I forgot almost all of functional analysis after passing the test.
I'd like to have a version that works for f : E → real
with infinite dimensional E
(hence infinite-dimensional ker df
)
It should work if E / ker df
is finite dimensional: lift it somehow into E
, and this lift is continuous because E / ker df
is finite dimensional.
Are there any examples of E
, p : submodule E
, is_closed p
such that there is no right inverse to the projection E → p.quotient
?
I think that having a continuous right-inverse to the quotient map is the same thing as asking for a closed complement.
But when the target has finite dimension then the kernel has finite codimension and there won't be any problem, right?
https://math.stackexchange.com/a/108289/1162 claims that in general you need hypotheses to find a closed complement of a closed subspace of a Banach space.
Of course!
Does that contradict anything I wrote?
No not at all Patrick! I was just answering Yury's question.
I think that bit was clear to Yury as well. I'm pretty he met dense subspaces of Banach spaces (that are not the whole space).
I definitely met dense subspaces. The question was about a closed complement to a closed subspace of a Banach space.
So I should ask for a continuous right inverse instead of surjectivity, OK.
Possibly I'll formalize the fact that c_0
has no closed complement in l^\infty
.
Last updated: Apr 24 2020 at 19:02 UTC


E-Note Book
Add Project
Personal
Work
Doctor Appoinment
Call the plumper
complete test case document
Meet the manager
Add Task
Project name:
Task name:


Today
4 Tasks
4 Meetings
Monday, 20
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile
Change the tires of the Catmobile


Please check your email for further instructions on how to complete your account setup.
Having trouble? Contact us
Continue to homepage


Galaxy launches a Christmas cracker full of CAKE as part of its festive range
There are also festive hot chocolate pods!
by Nancy BrownChristmas is a time to pull a cracker – and they surely don't come much better than this launch from chocolatiers Galaxy.
Galaxy's limited-edition Cake Bar Cracker is on sale in Spar stores now and costs just £2.50.
It features a selection of some of the brand's festive favourites.
Read more: Pizza Express reveals Snowball Dough Balls are back for Christmas 2019
The cracker includes the Salted Caramel and Orange Festive Cake Bars, as well as the ever-popular Galaxy and Galaxy Caramel Cake Bars.
Elsewhere, fans can buy packets of the Festive Cake Bars – which feature five individually-wrapped light and spongey chocolate cakes topped with orange or salted caramel sauce.
They're just £1 from Tesco, Asda, Co-Op, Morrisons and Sainsbury's.

Chocoholics can enjoy their favourite chocolate bar in a warming drink this Christmas, with the new Twix, Milky Way, Galaxy and Maltesers hot chocolate pods.
Or enjoy one of the Galaxy Hot Chocolate pods – flavoured with orange, Irish cream, milk and white chocolate drinks.
They're priced at £3.79 and only available in B&M.
Read more: Lidl is selling a cheese advent calendar for just £7.99
There's also a range of warming Galaxy hot chocolates, with the seasonal tubs decorated with a polar bear, penguin and a fox.
Or there's the Ultimate Frothy Hot Chocolate for that real coffee shop-style drink.
Let us know which you'll be trying on our Facebook page @EntertainmentDailyFix.


Release 0.10.2¶
Release summary¶
This is a bug release and adds compatibility with Python 3.8.
Development summary and credits¶
Besides receiving contributions for new and improved features and for bugfixes, important contributions to general maintenance for this release came from
Chad Fulton
Qingqing Mao
Diego Mazon
Brock Mendel
Guglielmo Saggiorato
Kevin Sheppard
Tim Staley
Merged Pull Requests¶
The following Pull Requests were merged since the last release:
PR #5935: CLN: port parts of #5220
PR #5951: BUG: Fix mosaic plot with missing category
PR #5996: BUG: Limit lags in KPSS
PR #5998: Replace alpha=0.05 with alpha=alpha
PR #6030: Turn relative import into an absolute import
PR #6044: DOC: Fix notebook due to pandas index change
PR #6046: DOC: Remove DynamicVAR
PR #6091: MAINT/SEC: Remove unnecessary pickle use
PR #6092: MAINT: Ensure r download cache works
PR #6093: MAINT: Fix new cache name
PR #6117: BUG: Remove extra LICENSE.txt and setup.cfg
PR #6105: Update correlation_tools.py
PR #6050: BUG: MLEModel now passes nobs to Representation
PR #6205: MAINT: Exclude pytest-xdist 1.30
PR #6246: TST: Add Python 3.8 environment


Bioinformatics is an interdisciplinary field that develops methods and software tools for understanding biological data. As an interdisciplinary field of science, bioinformatics combines biology, computer science, information engineering, mathematics and statistics to analyze and interpret biological data. Bioinformatics has been used for in silico analyses of biological queries using mathematical and statistical techniques.
Bioinformatics includes biological studies that use computer programming as part of their methodology, as well as a specific analysis "pipelines" that are repeatedly used, particularly in the field of genomics. Common uses of bioinformatics include the identification of candidates genes and single nucleotide polymorphisms (SNPs). Often, such identification is made with the aim of better understanding the genetic basis of disease, unique adaptations, desirable properties (esp. in agricultural species), or differences between populations. In a less formal way, bioinformatics also tries to understand the organisational principles within nucleic acid and protein sequences, called proteomics.
Bioinformatics has become an important part of many areas of biology. In experimental molecular biology, bioinformatics techniques such as image and signal processing allow extraction of useful results from large amounts of raw data. In the field of genetics, it aids in sequencing and annotating genomes and their observed mutations. It plays a role in the text mining of biological literature and the development of biological and gene ontologies to organize and query biological data. It also plays a role in the analysis of gene and protein expression and regulation. Bioinformatics tools aid in the comparison of genetic and genomic data and more generally in the understanding of evolutionary aspects of molecular biology. At a more integrative level, it helps analyze and catalogue the biological pathways and networks that are an important part of systems biology. In structural biology, it aids in the simulation and modeling of DNA, RNA, proteins as well as biomolecular interactions.
Historically, the term bioinformatics did not mean what it means today. Paulien Hogeweg and Ben Hesper coined it in 1970 to refer to the study of information processes in biotic systems. This definition placed bioinformatics as a field parallel to biochemistry (the study of chemical processes in biological systems).
Computers became essential in molecular biology when protein sequences became available after Frederick Sanger determined the sequence of insulin in the early 1950s. Comparing multiple sequences manually turned out to be impractical. A pioneer in the field was Margaret Oakley Dayhoff.[12] She compiled one of the first protein sequence databases, initially published as books[13] and pioneered methods of sequence alignment and molecular evolution. Another early contributor to bioinformatics was Elvin A. Kabat, who pioneered biological sequence analysis in 1970 with his comprehensive volumes of antibody sequences released with Tai Te Wu between 1980 and 1991.


TGMapViewDelegate
@protocol TGMapViewDelegate <NSObject>
A map view delegate can receive various map events.
Note
All of these methods are called from main thread, these methods are all optional.-
Receive the result from
-[TGMapView pickFeatureAt:]
.Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView didSelectFeature:(nullable TGFeatureProperties *)feature atScreenPosition:(CGPoint)position;
Swift
optional func mapView(_ mapView: TGMapView, didSelectFeature feature: [String : String]?, atScreenPosition position: CGPoint)
Parameters
mapView
The map view instance.
feature
A dictionary of properties of the picked feature or
nil
if no feature was found.position
The view position where the feature was picked.
-
Receive the result from
-[TGMapView pickLabelAt:]
.Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView didSelectLabel:(nullable TGLabelPickResult *)labelPickResult atScreenPosition:(CGPoint)position;
Swift
optional func mapView(_ mapView: TGMapView, didSelectLabel labelPickResult: TGLabelPickResult?, atScreenPosition position: CGPoint)
Parameters
mapView
The map view instance.
labelPickResult
A result object with information about the picked label or
nil
if no label was found.position
The view position where the label was picked.
-
Receive the result from
-[TGMapView pickMarkerAt:]
.Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView didSelectMarker:(nullable TGMarkerPickResult *)markerPickResult atScreenPosition:(CGPoint)position;
Swift
optional func mapView(_ mapView: TGMapView, didSelectMarker markerPickResult: TGMarkerPickResult?, atScreenPosition position: CGPoint)
Parameters
mapView
The map view instance.
markerPickResult
A result object with information about the picked marker or
nil
if no marker was found.position
The view position where the marker was picked.
-
Receive the result from
-[TGMapView captureScreenshot:]
.Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView didCaptureScreenshot:(nonnull UIImage *)screenshot;
Swift
optional func mapView(_ mapView: TGMapView, didCaptureScreenshot screenshot: UIImage)
Parameters
mapView
The map view instance.
screenshot
The image object representing the screenshot.
-
Called after a scene has been loaded or updated.
See:
-[TGMapView loadSceneAsyncFromURL:withUpdates:]
-[TGMapView loadSceneFromYAML:relativeToURL:withUpdates:]
-[TGMapView loadSceneAsyncFromYAML:relativeToURL:withUpdates:]
Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView didLoadScene:(int)sceneID withError:(nullable NSError *)sceneError;
Swift
optional func mapView(_ mapView: TGMapView, didLoadScene sceneID: Int32, withError sceneError: Error?)
Parameters
mapView
The map view instance.
sceneID
The ID of the scene that was loaded or updated.
sceneError
Any error encountered while loading or updating the scene.
-
Called immediately before the displayed map region moves.
Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView regionWillChangeAnimated:(BOOL)animated;
Swift
optional func mapView(_ mapView: TGMapView, regionWillChangeAnimated animated: Bool)
Parameters
mapView
The map view instance.
animated
If YES the move will be animated over time, if NO the move will happen immediately.
-
Called after the displayed map region moves.
Declaration
Objective-C
- (void)mapView:(nonnull TGMapView *)mapView regionDidChangeAnimated:(BOOL)animated;
Swift
optional func mapView(_ mapView: TGMapView, regionDidChangeAnimated animated: Bool)
Parameters
mapView
The map view instance.
animated
If YES the move was animated over time, if NO the move happened immediately.