{"history":[],"article":{"id":"8bc62d42-fb45-4316-a83b-e00fc04e8da3","title":"Icon (programming language)","slug":"icon-programming-language","content":":::summary\n![Icon](https://upload.wikimedia.org/wikipedia/commons/c/cf/Icon///logo.png)\n**Name:** Icon \n**Paradigms:** [multi-paradigm](https://bliptext.com/articles/multi-paradigm-programming-language): [structured](https://bliptext.com/articles/structured-programming), text-oriented \n**Family:** [SNOBOL](https://bliptext.com/articles/snobol) \n**Designer:** [Ralph Griswold](https://bliptext.com/articles/ralph-griswold) \n**Typing:** [dynamic](https://bliptext.com/articles/dynamic-typing) \n**Website:** www.cs.arizona.edu/icon \n**Year:** 1977 \n**Latest Release Version:** 9.5.24a \n**Latest Release Date:** January 17, 2024 \n**Implementations:** Icon, Jcon \n**Dialects:** [Unicon](https://bliptext.com/articles/unicon-programming-language) \n**Influenced By:** [SNOBOL](https://bliptext.com/articles/snobol), SL5, [ALGOL](https://bliptext.com/articles/algol) \n**Influenced:** Unicon, [Python](https://bliptext.com/articles/python-programming-language), Goaldi, [jq](https://bliptext.com/articles/jq-programming-language) \n:::\n\n# \n**Icon** is a [very high-level programming language](https://bliptext.com/articles/very-high-level-programming-language) based on the concept of \"goal-directed execution\" in which code returns a \"success\" along with valid values, or a \"failure\", indicating that there is no valid data to return.\nThe success and failure of a given block of code is used to direct further processing, whereas conventional languages would typically use [Boolean logic](https://bliptext.com/articles/boolean-logic) written by the programmer to achieve the same ends.\nBecause the logic for basic control structures is often implicit in Icon, common tasks can be completed with less explicit code.\nIcon was designed by [Ralph Griswold](https://bliptext.com/articles/ralph-griswold) after leaving [Bell Labs](https://bliptext.com/articles/bell-labs) where he was a major contributor to the [SNOBOL](https://bliptext.com/articles/snobol) language.\nSNOBOL was a string-processing language with what would be considered dated syntax by the standards of the early 1970s.\nAfter moving to the [University of Arizona](https://bliptext.com/articles/university-of-arizona), he further developed the underlying SNOBOL concepts in SL5, but considered the result to be a failure.\nThis led to the significantly updated Icon, which blends the short but conceptually dense code of SNOBOL-like languages with the more familiar syntax of [ALGOL](https://bliptext.com/articles/algol)-inspired languages like [C](https://bliptext.com/articles/c-programming-language) or [Pascal](https://bliptext.com/articles/pascal-programming-language).\nLike the languages that inspired it, the primary area of use of Icon is managing [strings](https://bliptext.com/articles/string-computer-science) and textual patterns.\nString operations often fail, for instance, finding \"the\" in \"world\".\nIn most languages, this requires testing and branching to avoid using a non-valid result.\nIn Icon most of these sorts of tests are simply unneeded, reducing the amount of code that must be written.\nComplex pattern handling can be done in a few lines of terse code, similar to more dedicated languages like [Perl](https://bliptext.com/articles/perl) but retaining a more function-oriented syntax familiar to users of other ALGOL-like languages.\nIcon is not [object-oriented](https://bliptext.com/articles/object-oriented-programming), but an [object-oriented](https://bliptext.com/articles/object-oriented-programming) extension named Idol was developed in 1996 which eventually became [Unicon](https://bliptext.com/articles/unicon-programming-language).\nIt also inspired other languages, with its simple generators being especially influential; Icon's generators were a major inspiration for the [Python](https://bliptext.com/articles/python-programming-language) language.\n\n# History\n\n## SNOBOL\nThe original [SNOBOL](https://bliptext.com/articles/snobol) effort, retroactively known as [SNOBOL](https://bliptext.com/articles/snobol)1, launched in the fall of 1962 at the [Bell Labs](https://bliptext.com/articles/bell-labs) Programming Research Studies Department.\nThe effort was a reaction to the frustrations of attempting to use the SCL language for polynomial formula manipulation, symbolic integration and studying [Markov chains](https://bliptext.com/articles/markov-chain).\nSCL, written by the department head Chester Lee, was both slow and had a low-level syntax that resulting in volumes of code for even simple projects.\nAfter briefly considering the COMIT language, Ivan Polonsky, Ralph Griswold and David Farber, all members of the six-person department, decided to write their own language to solve these problems.\nThe first versions were running on the [IBM 7090](https://bliptext.com/articles/ibm-7090) in early 1963, and by the summer had been built out and was being used across Bell.\nThis led almost immediately to SNOBOL2, which added a number of built-in functions, and the ability to link to external [assembly language](https://bliptext.com/articles/assembly-language) code.\nIt was released in April 1964 and mostly used within Bell, but also saw some use at [Project MAC](https://bliptext.com/articles/project-mac).\nThe introduction of system functions served mostly to indicate the need for user functions, which was the major feature of SNOBOL3, released in July 1964.\nSNOBOL3's introduction corresponded with major changes within the Bell Labs computing department, including the addition of the new [GE 645](https://bliptext.com/articles/ge-645) mainframe which would require a rewrite of SNOBOL.\nInstead, the team suggested writing a new version that would run on a [virtual machine](https://bliptext.com/articles/virtual-machine), named SIL for SNOBOL Intermediate Language, allowing it to be easily ported to any sufficiently powerful platform.\nThis proposal was accepted as SNOBOL4 in September 1965.\nBy this time, plans for a significantly improved version of the language emerged in August 1966.\nFurther work on the language continued throughout the rest of the 1960s, notably adding the [associative array](https://bliptext.com/articles/associative-array) type in later version, which they referred to as a table.\n\n## SL5 leads to Icon\nGriswold left Bell Labs to become a professor at the [University of Arizona](https://bliptext.com/articles/university-of-arizona) in August 1971.\nHe introduced SNOBOL4 as a research tool at that time.\nHe received grants from the [National Science Foundation](https://bliptext.com/articles/national-science-foundation) to continue supporting and evolving SNOBOL.\nAs a language originally developed in the early 1960s, SNOBOL's syntax bears the marks of other early programming languages like [FORTRAN](https://bliptext.com/articles/fortran) and [COBOL](https://bliptext.com/articles/cobol).\nIn particular, the language is column-dependant, as many of these languages were entered on [punch cards](https://bliptext.com/articles/punch-card) where column layout is natural.\nAdditionally, control structures were almost entirely based on branching around code rather than the use of [blocks](https://bliptext.com/articles/block-programming), which were becoming a must-have feature after the introduction of [ALGOL 60](https://bliptext.com/articles/algol-60).\nBy the time he moved to Arizona, the syntax of SNOBOL4 was hopelessly outdated.\nGriswold began the effort of implementing SNOBOL's underlying success/failure concept with traditional flow control structures like if/then.\nThis became SL5, short for \"SNOBOL Language 5\", but the result was unsatisfying.\nIn 1977, he returned to the language to consider a new version.\nHe abandoned the very powerful function system introduced in SL5 with a simpler concept of suspend/resume and developed a new concept for the natural successor to SNOBOL4 with the following principles;\nThe new language was initially known as SNOBOL5, but as it was significantly different from SNOBOL in all but the underlying concept, a new name was ultimately desired.\nAfter considering \"s\" as a sort of homage to \"C\", but this was ultimately abandoned due to the problems with typesetting documents using that name.\nA series of new names were proposed and abandoned; Irving, bard, and \"TL\" for \"The Language\".\nIt was at this time that [Xerox PARC](https://bliptext.com/articles/xerox-parc) began publishing about their work on [graphical user interfaces](https://bliptext.com/articles/graphical-user-interface) and the term \"icon\" began to enter the computer lexicon.\nThe decision was made to change the name initially to \"icon\" before finally choosing \"Icon\".\n\n# Language\n\n## Basic syntax\nThe Icon language is derived from the [ALGOL](https://bliptext.com/articles/algol)-class of [structured programming](https://bliptext.com/articles/structured-programming) languages, and thus has syntax similar to [C](https://bliptext.com/articles/c-programming-language) or [Pascal](https://bliptext.com/articles/pascal-programming-language).\nIcon is most similar to Pascal, using := syntax for assignments, the procedure keyword and similar syntax.\nOn the other hand, Icon uses C-style braces for structuring execution groups, and programs start by running a procedure called main.\nIn many ways Icon also shares features with most [scripting languages](https://bliptext.com/articles/scripting-language) (as well as [SNOBOL](https://bliptext.com/articles/snobol) and SL5, from which they were taken): variables do not have to be declared, types are cast automatically, and numbers can be converted to strings and back automatically.\nAnother feature common to many scripting languages, but not all, is the lack of a line-ending character; in Icon, lines that do not end with a semicolon get ended by an implied semicolon if it makes sense.\nProcedures are the basic building blocks of Icon programs.\nAlthough they use Pascal naming, they work more like C functions and can return values; there is no function keyword in Icon.\n\n## Goal-directed execution\nOne of the key concepts in SNOBOL was that its functions returned the \"success\" or \"failure\" as primitives of the language rather than using [magic numbers](https://bliptext.com/articles/magic-number-programming) or other techniques.\nFor instance, a function that returns the position of a substring within another string is a common routine found in most language [runtime systems](https://bliptext.com/articles/runtime-system); in [JavaScript](https://bliptext.com/articles/javascript) one might want to find the position of the word \"World\" within a [\"Hello, World!\" program](https://bliptext.com/articles/hello-world-program), which would be done with icon, which would return 7.\nIf one instead asks for the icon the code will \"fail\", as the search term does not appear in the string.\nIn JavaScript, as in most languages, this will be indicated by returning a magic number, in this case -1.\nIn SNOBOL a failure of this sort returns a special value, fail.\nSNOBOL's syntax operates directly on the success or failure of the operation, jumping to labelled sections of the code without having to write a separate test.\nFor instance, the following code prints \"Hello, world!\"\nfive times:\nTo perform the loop, the less-than-or-equal operator, LE, is called on the index variable I, and if it Succeeds, meaning I is less than 5, it branches to the named label LOOP and continues.\nIcon retained the concept of flow control based on success or failure but developed the language further.\nOne change was the replacement of the labelled GOTO-like branching with block-oriented structures in keeping with the [structured programming](https://bliptext.com/articles/structured-programming) style that was sweeping the computer industry in the late 1960s.\nThe second was to allow \"failure\" to be passed along the call chain so that entire blocks will succeed or fail as a whole.\nThis is a key concept of the Icon language.\nWhereas in traditional languages one would have to include code to test the success or failure based on [Boolean logic](https://bliptext.com/articles/boolean-logic) and then branch based on the outcome, such tests and branches are inherent to Icon code and do not have to be explicitly written.\nFor instance, consider this bit of code written in the [Java programming language](https://bliptext.com/articles/java-programming-language).\nIt calls the function read to read a character from a (previously opened) file, assigns the result to the variable a, and then writes the value of a to another file.\nThe result is to copy one file to another.\nread will eventually run out of characters to read from the file, potentially on its very first call, which would leave a in an undetermined state and potentially cause write to cause a [null pointer exception](https://bliptext.com/articles/null-pointer-exception).\nTo avoid this, read returns the special value EOF (end-of-file) in this situation, which requires an explicit test to avoid writeing it:\nIn contrast, in Icon the read function returns a line of text or &fail.\n&fail is not simply an analog of EOF, as it is explicitly understood by the language to mean \"stop processing\" or \"do the fail case\" depending on the context.\nThe equivalent code in Icon is:\nThis means, \"as long as read does not fail, call write, otherwise stop\".\nThere is no need to specify a test against the magic number as in the Java example, this is implicit, and the resulting code is simplified.\nBecause success and failure are passed up through the call chain, one can embed function calls within others and they stop when the nested function call fails.\nFor instance, the code above can be reduced to:\nIn this version, if the read call fails, the write call fails, and the while stops.\nIcon's branching and looping constructs are all based on the success or failure of the code inside them, not on an arbitrary Boolean test provided by the programmer.\nif performs the then block if its \"test\" returns a value, and performs the else block or moves to the next line if it returns &fail.\nLikewise, while continues calling its block until it receives a fail.\nIcon refers to this concept as **goal-directed execution**.\nIt is important to contrast the concept of success and failure with the concept of an [exception](https://bliptext.com/articles/exception-handling); [exception](https://bliptext.com/articles/exception-handling)s are unusual situations, not expected outcomes.\nFails in Icon are expected outcomes; reaching the end of a file is an expected situation and not an exception.\nIcon does not have exception handling in the traditional sense, although fail is often used in exception-like situations.\nFor instance, if the file being read does not exist, read fails without a special situation being indicated.\nIn traditional language, these \"other conditions\" have no natural way of being indicated; additional magic numbers may be used, but more typically exception handling is used to \"throw\" a value.\nFor instance, to handle a missing file in the Java code, one might see:\nThis case needs two comparisons: one for EOF and another for all other errors.\nSince Java does not allow exceptions to be compared as logic elements, as under Icon, the lengthy try/catch syntax must be used instead.\nTry blocks also impose a performance penalty even if no exception is thrown, a [distributed cost](https://bliptext.com/articles/distributed-cost) that Icon normally avoids.\nIcon uses this same goal-directed mechanism to perform traditional Boolean tests, although with subtle differences.\nA simple comparison like if a < b then write(\"a is smaller than b\") does not mean, \"if the conditional expression evaluation results in or returns a true value\" as they would under most languages; instead, it means something more like, \"if the conditional expression, here < operation, succeeds and does not fail\".\nIn this case, the < operator succeeds if the comparison is true.\nThe if calls its then clause if the expression succeeds, or the else or the next line if it fails.\nThe result is similar to the traditional if/then seen in other languages, the if performs then if a is less than b. The subtlety is that the same comparison expression can be placed anywhere, for instance:\nAnother difference is that the < operator returns its second argument if it succeeds, which in this example will result in the value of b being written if it is larger than a, otherwise nothing is written.\nAs this is not a test per se, but an operator that returns a value, they can be strung together allowing things like if a < b < c, a common type of comparison that in most languages must be written as a conjunction of two inequalities like if (a < b) && (b < c).\nA key aspect of goal-directed execution is that the program may have to rewind to an earlier state if a procedure fails, a task known as backtracking.\nFor instance, consider code that sets a variable to a starting location and then performs operations that may change the value - this is common in string scanning operations for instance, which will advance a cursor through the string as it scans.\nIf the procedure fails, it is important that any subsequent reads of that variable return the original state, not the state as it was being internally manipulated.\nFor this task, Icon has the reversible assignment operator, <-, and the reversible exchange, <->.\nFor instance, consider some code that is attempting to find a pattern string within a larger string:\nThis code begins by moving i to 10, the starting location for the search.\nHowever, if the find fails, the block will fail as a whole, which results in the value of i being left at 10 as an undesirable [side effect](https://bliptext.com/articles/side-effect-computer-science).\nReplacing i := 10 with i <- 10 indicates that i should be reset to its previous value if the block fails.\nThis provides an analog of [atomicity](https://bliptext.com/articles/atomic-commit) in the execution.\n\n## Generators\nExpressions in Icon may return a single value, for instance, 5 > x will evaluate and return x if the value of x is less than 5, or else fail.\nHowever, Icon also includes the concept of procedures that do not immediately return success or failure, and instead return new values every time they are called.\nThese are known as generators, and are a key part of the Icon language.\nWithin the parlance of Icon, the evaluation of an expression or function produces a result sequence.\nA result sequence contains all the possible values that can be generated by the expression or function.\nWhen the result sequence is exhausted, the expression or function fails.\nIcon allows any procedure to return a single value or multiple values, controlled using the fail, return and suspend keywords.\nA procedure that lacks any of these keywords returns &fail, which occurs whenever execution runs to the end of a procedure.\nFor instance:\nCalling f(5) will return 1, but calling f(-1) will return &fail.\nThis can lead to non-obvious behavior, for instance, write(f(-1)) will output nothing because f fails and suspends operation of write.\nConverting a procedure to be a generator uses the suspend keyword, which means \"return this value, and when called again, start execution at this point\".\nIn this respect it is something like a combination of the [static](https://bliptext.com/articles/static-keyword) concept in C and return.\nFor instance:\ncreates a generator that returns a series of numbers starting at i and ending a j, and then returns &fail after that.\nThe suspend i stops execution and returns the value of i without reseting any of the state.\nWhen another call is made to the same function, execution picks up at that point with the previous values.\nIn this case, that causes it to perform i +:= 1, loop back to the start of the while block, and then return the next value and suspend again.\nThis continues until i <= j fails, at which point it exits the block and calls fail.\nThis allows [iterators](https://bliptext.com/articles/iterator) to be constructed with ease.\nAnother type of generator-builder is the alternator, which looks and operates like the Boolean or operator.\nFor instance:\nThis appears to say \"if y is smaller than x or 5 then...\", but is actually a short-form for a generator that returns values until it falls off the end of the list.\nThe values of the list are \"injected\" into the operations, in this case, <.\nSo in this example, the system first tests y < x, if x is indeed larger than y it returns the value of x, the test passes, and the value of y is written out in the then clause.\nHowever, if x is not larger than y it fails, and the alternator continues, performing y < 5.\nIf that test passes, y is written.\nIf y is smaller than neither x or 5, the alternator runs out of tests and fails, the if fails, and the write is not performed.\nThus, the value of y will appear on the console if it is smaller than x or 5, thereby fulfilling the purpose of a Boolean or.\nFunctions will not be called unless evaluating their parameters succeeds, so this example can be shortened to:\nInternally, the alternator is not simply an or and one can also use it to construct arbitrary lists of values.\nThis can be used to iterate over arbitrary values, like:\nAs lists of integers are commonly found in many programming contexts, Icon also includes the to keyword to construct ad hoc integer generators:\nwhich can be shortened:\nIcon is not strongly typed, so the alternator lists can contain different types of items:\nThis writes 1, \"hello\" and maybe 5 depending on the value of x.\nLikewise the conjunction operator, &, is used in a fashion similar to a Boolean and operator:\nThis code calls ItoJ and returns an initial value of 0 which is assigned to x. It then performs the right-hand side of the conjunction, and since x % 2 does equal 0, it writes out the value.\nIt then calls the ItoJ generator again which assigns 1 to x, which fails the right-hand-side and prints nothing.\nThe result is a list of every even integer from 0 to 10.\nThe concept of generators is particularly useful and powerful when used with string operations, and is a major underlying basis for Icon's overall design.\nConsider the indexOf operation found in many languages; this function looks for one string within another and returns an index of its location, or a magic number if it is not found.\nFor instance:\nThis will scan the string s, find the first occurrence of \"the\", and return that index, in this case 4.\nThe string, however, contains two instances of the string \"the\", so to return the second example an alternate syntax is used:\nThis tells it to scan starting at location 5, so it will not match the first instance we found previously.\nHowever, there may not be a second instance of \"the\" -there may not be a first one either- so the return value from indexOf has to be checked against the magic number -1 which is used to indicate no matches.\nA complete routine that prints out the location of every instance is:\nIn Icon, the equivalent find is a generator, so the same results can be created with a single line:\nOf course there are times where one does want to find a string after some point in input, for instance, if scanning a text file that contains a line number in the first four columns, a space, and then a line of text.\nGoal-directed execution can be used to skip over the line numbers:\nThe position will only be returned if \"the\" appears after position 5; the comparison will fail otherwise, pass the fail to write, and the write will not occur.\nThe every operator is similar to while, looping through every item returned by a generator and exiting on failure:\nThere is a key difference between every and while; while re-evaluates the first result until it fails, whereas every fetches the next value from a generator.\nevery actually injects values into the function in a fashion similar to blocks under [Smalltalk](https://bliptext.com/articles/smalltalk).\nFor instance, the above loop can be re-written this way:\nIn this case, the values from i to j will be injected into someFunction and (potentially) write multiple lines of output.\n\n## Collections\nIcon includes several [collection types](https://bliptext.com/articles/collection-abstract-data-type) including [lists](https://bliptext.com/articles/list-abstract-data-type) that can also be used as [stacks](https://bliptext.com/articles/stack-abstract-data-type) and [queues](https://bliptext.com/articles/queue-abstract-data-type), [tables](https://bliptext.com/articles/associative-array) (also known as maps or dictionaries in other languages), [sets](https://bliptext.com/articles/set-abstract-data-type) and others.\nIcon refers to these as structures.\nCollections are inherent generators and can be easily called using the bang syntax.\nFor instance:\nUsing the fail propagation as seen in earlier examples, we can combine the tests and the loops:\nBecause the list collection is a generator, this can be further simplified with the bang syntax:\nIn this case, the bang in write causes Icon to return a line of text one by one from the array and finally fail at the end.\n&input is a generator-based analog of read that reads a line from [standard input](https://bliptext.com/articles/standard-input), so !&input continues reading lines until the file ends.\nAs Icon is typeless, lists can contain any different types of values:\nThe items can included other structures.\nTo build larger lists, Icon includes the list generator; generates a list containing 10 copies of \"word\".\nLike arrays in other languages, Icon allows items to be looked up by position, e.g.,.\n[Array slicing](https://bliptext.com/articles/array-slicing) is included, allowing new lists to be created out of the elements of other lists, for instance, aCat := Cats[2:4] produces a new list called aCat that contains \"tabby\" and 2002.\nTables are essentially lists with arbitrary index keys rather than integers:\nThis code creates a table that will use zero as the default value of any unknown key.\nIt then adds two items into the table, with the keys \"there\" and \"here\", and values 1 and 2.\nSets are also similar to lists but contain only a single member of any given value.\nIcon includes the ++ to produce the union of two sets, ** the intersection, and -- the difference.\nIcon includes a number of pre-defined \"Cset\"s, a set containing various characters.\nThere are four standard Csets in Icon, &ucase, &lcase, &letters, and &digits.\nNew Csets can be made by enclosing a string in single quotes, for instance, vowel := 'aeiou'.\n\n## Strings\nIn Icon, strings are lists of characters.\nAs a list, they are generators and can thus be iterated over using the bang syntax:\nWill print out each character of the string on a separate line.\nSubstrings can be extracted from a string by using a range specification within brackets.\nA range specification can return a point to a single character, or a [slice](https://bliptext.com/articles/array-slicing) of the string.\nStrings can be indexed from either the right or the left.\nPositions within a string are defined to be **between** the characters 1A2B3C4 and can be specified from the right −3A−2B−1C0\nFor example,\nWhere the last example shows using a length instead of an ending position\nThe subscripting specification can be used as a [lvalue](https://bliptext.com/articles/value-computer-science) within an expression.\nThis can be used to insert strings into another string or delete parts of a string.\nFor example:\n\n## String scanning\nA further simplification for handling strings is the scanning system, invoked with ?, which calls functions on a string:\nIcon refers to the left-hand-side of the ?\nas the subject, and passes it into string functions.\nRecall the find takes two parameters, the search text as parameter one and the string to search in parameter two.\nUsing ?\nthe second parameter is implicit and does not have to be specified by the programmer.\nIn the common cases when multiple functions are being called on a single string in sequence, this style can significantly reduce the length of the resulting code and improve clarity.\nIcon function signatures identify the subject parameter in their definitions so the parameter can be [hoisted](https://bliptext.com/articles/loop-invariant-code-motion) in this fashion.\nThe ?\nis not simply a form of syntactic sugar, it also sets up a \"string scanning environment\" for any following string operations.\nThis is based on two internal variables, &subject and &pos; &subject is simply a pointer to the original string, while &pos is the current position within it, or cursor.\nIcon's various string manipulation procedures use these two variables so they do not have to be explicitly supplied by the programmer.\nFor example:\nwould produce:\nBuilt-in and user-defined functions can be used to move around within the string being scanned.\nAll of the built-in functions will default to &subject and &pos to allow the scanning syntax to be used.\nThe following code will write all blank-delimited \"words\" in a string:\nThere are a number of new functions introduced in this example.\npos returns the current value of &pos.\nIt may not be immediately obvious why one would need this function and not simply use the value of &pos directly; the reason is that &pos is a variable and thus cannot take on the value &fail, which the procedure pos can.\nThus pos provides a lightweight wrapper on &pos that allows Icon's goal-directed flow control to be easily used without having to provide hand-written Boolean tests against &pos.\nIn this case, the test is \"is &pos zero\", which, in the odd numbering of Icon's string locations, is the end of the line.\nIf it is not zero, pos returns &fail, which is inverted with the not and the loop continues.\nmany finds one or more examples of the provided Cset parameter starting at the current &pos.\nIn this case, it is looking for space characters, so the result of this function is the location of the first non-space character after &pos.\ntab moves &pos to that location, again with a potential &fail in case, for instance, many falls off the end of the string.\nupto is essentially the reverse of many; it returns the location immediately prior to its provided Cset, which the example then sets the &pos to with another tab.\nAlternation is used to also stop at the end of a line.\nThis example can be made more robust through the use of a more appropriate \"word breaking\" Cset which might include periods, commas and other punctuation, as well as other whitespace characters like tab and non-breaking spaces.\nThat Cset can then be used in many and upto.\nA more complex example demonstrates the integration of generators and string scanning within the language.\n\n# Criticisms\nLaurence Tratt wrote a paper on Icon examining its real-world applications and pointing out a number of areas of concern.\nAmong these were a number of practical decisions that derive from their origins in string processing but do not make as much sense in other areas.\nAmong them:\nThe decision to fail by default at the end of procedures makes sense in the context of generators, but less so in the case of general procedures.\nReturning to the example noted above, write(f(-1)) will not output which may be expected.\nHowever:\nwill result in 10 being printed.\nThis sort of issue is not at all obvious as even in an interactive debugger all the code is invoked yet x never picks up the expected value.\nThis could be dismissed as one of those \"gotchas\" that programmers have to be aware of in any language, but Tratt examined a variety of Icon programs and found that the vast majority of procedures are not generators.\nThis means that Icon's default behaviour is only used by a tiny minority of its constructs, yet represents a major source of potential errors in all the others.\nAnother issue is the lack of a Boolean data type and conventional Boolean logic.\nWhile the success/fail system works in most cases where the ultimate goal is to check a value, this can still lead to some odd behaviour in seemingly simple code:\nThis program will print \"taken\".\nThe reason is that the test, c, does return a value; that value is &null, the default value for all otherwise uninitiated variables.\n&null is a valid value, so if c succeeds.\nTo test this, one needs to make the test explicit,.\nTratt supposed that it detracts from the self-documenting code, having supposed erroneously that it is testing \"is c zero\" or \"does c exist\".\n\n# Citations","current_revision":null,"created_by":"kACnuQmH5k9Nr5VNVEpVeg7XpvUmMctD","created_at":"2025-01-25T16:46:03.843Z","updated_at":"2025-01-25T16:46:03.843Z","search_vector":"'icon':1 'languag':3 'program':2","search_content":" \n \n**Name:** Icon \n**Paradigms:** [multi-paradigm](https://bliptext.com/articles/multi-paradigm-programming-language): [structured](https://bliptext.com/articles/structured-programming), text-oriented \n**Family:** [SNOBOL](https://bliptext.com/articles/snobol) \n**Designer:** [Ralph Griswold](https://bliptext.com/articles/ralph-griswold) \n**Typing:** [dynamic](https://bliptext.com/articles/dynamic-typing) \n**Website:** www.cs.arizona.edu/icon \n**Year:** 1977 \n**Latest Release Version:** 9.5.24a \n**Latest Release Date:** January 17, 2024 \n**Implementations:** Icon, Jcon \n**Dialects:** [Unicon](https://bliptext.com/articles/unicon-programming-language) \n**Influenced By:** [SNOBOL](https://bliptext.com/articles/snobol), SL5, [ALGOL](https://bliptext.com/articles/algol) \n**Influenced:** Unicon, [Python](https://bliptext.com/articles/python-programming-language), Goaldi, [jq](https://bliptext.com/articles/jq-programming-language) \n \n\n# \n**Icon** is a [very high-level programming language](https://bliptext.com/articles/very-high-level-programming-language) based on the concept of \"goal-directed execution\" in which code returns a \"success\" along with valid values, or a \"failure\", indicating that there is no valid data to return.\nThe success and failure of a given block of code is used to direct further processing, whereas conventional languages would typically use [Boolean logic](https://bliptext.com/articles/boolean-logic) written by the programmer to achieve the same ends.\nBecause the logic for basic control structures is often implicit in Icon, common tasks can be completed with less explicit code.\nIcon was designed by [Ralph Griswold](https://bliptext.com/articles/ralph-griswold) after leaving [Bell Labs](https://bliptext.com/articles/bell-labs) where he was a major contributor to the [SNOBOL](https://bliptext.com/articles/snobol) language.\nSNOBOL was a string-processing language with what would be considered dated syntax by the standards of the early 1970s.\nAfter moving to the [University of Arizona](https://bliptext.com/articles/university-of-arizona), he further developed the underlying SNOBOL concepts in SL5, but considered the result to be a failure.\nThis led to the significantly updated Icon, which blends the short but conceptually dense code of SNOBOL-like languages with the more familiar syntax of [ALGOL](https://bliptext.com/articles/algol)-inspired languages like [C](https://bliptext.com/articles/c-programming-language) or [Pascal](https://bliptext.com/articles/pascal-programming-language).\nLike the languages that inspired it, the primary area of use of Icon is managing [strings](https://bliptext.com/articles/string-computer-science) and textual patterns.\nString operations often fail, for instance, finding \"the\" in \"world\".\nIn most languages, this requires testing and branching to avoid using a non-valid result.\nIn Icon most of these sorts of tests are simply unneeded, reducing the amount of code that must be written.\nComplex pattern handling can be done in a few lines of terse code, similar to more dedicated languages like [Perl](https://bliptext.com/articles/perl) but retaining a more function-oriented syntax familiar to users of other ALGOL-like languages.\nIcon is not [object-oriented](https://bliptext.com/articles/object-oriented-programming), but an [object-oriented](https://bliptext.com/articles/object-oriented-programming) extension named Idol was developed in 1996 which eventually became [Unicon](https://bliptext.com/articles/unicon-programming-language).\nIt also inspired other languages, with its simple generators being especially influential; Icon's generators were a major inspiration for the [Python](https://bliptext.com/articles/python-programming-language) language.\n\n# History\n\n## SNOBOL\nThe original [SNOBOL](https://bliptext.com/articles/snobol) effort, retroactively known as [SNOBOL](https://bliptext.com/articles/snobol)1, launched in the fall of 1962 at the [Bell Labs](https://bliptext.com/articles/bell-labs) Programming Research Studies Department.\nThe effort was a reaction to the frustrations of attempting to use the SCL language for polynomial formula manipulation, symbolic integration and studying [Markov chains](https://bliptext.com/articles/markov-chain).\nSCL, written by the department head Chester Lee, was both slow and had a low-level syntax that resulting in volumes of code for even simple projects.\nAfter briefly considering the COMIT language, Ivan Polonsky, Ralph Griswold and David Farber, all members of the six-person department, decided to write their own language to solve these problems.\nThe first versions were running on the [IBM 7090](https://bliptext.com/articles/ibm-7090) in early 1963, and by the summer had been built out and was being used across Bell.\nThis led almost immediately to SNOBOL2, which added a number of built-in functions, and the ability to link to external [assembly language](https://bliptext.com/articles/assembly-language) code.\nIt was released in April 1964 and mostly used within Bell, but also saw some use at [Project MAC](https://bliptext.com/articles/project-mac).\nThe introduction of system functions served mostly to indicate the need for user functions, which was the major feature of SNOBOL3, released in July 1964.\nSNOBOL3's introduction corresponded with major changes within the Bell Labs computing department, including the addition of the new [GE 645](https://bliptext.com/articles/ge-645) mainframe which would require a rewrite of SNOBOL.\nInstead, the team suggested writing a new version that would run on a [virtual machine](https://bliptext.com/articles/virtual-machine), named SIL for SNOBOL Intermediate Language, allowing it to be easily ported to any sufficiently powerful platform.\nThis proposal was accepted as SNOBOL4 in September 1965.\nBy this time, plans for a significantly improved version of the language emerged in August 1966.\nFurther work on the language continued throughout the rest of the 1960s, notably adding the [associative array](https://bliptext.com/articles/associative-array) type in later version, which they referred to as a table.\n\n## SL5 leads to Icon\nGriswold left Bell Labs to become a professor at the [University of Arizona](https://bliptext.com/articles/university-of-arizona) in August 1971.\nHe introduced SNOBOL4 as a research tool at that time.\nHe received grants from the [National Science Foundation](https://bliptext.com/articles/national-science-foundation) to continue supporting and evolving SNOBOL.\nAs a language originally developed in the early 1960s, SNOBOL's syntax bears the marks of other early programming languages like [FORTRAN](https://bliptext.com/articles/fortran) and [COBOL](https://bliptext.com/articles/cobol).\nIn particular, the language is column-dependant, as many of these languages were entered on [punch cards](https://bliptext.com/articles/punch-card) where column layout is natural.\nAdditionally, control structures were almost entirely based on branching around code rather than the use of [blocks](https://bliptext.com/articles/block-programming), which were becoming a must-have feature after the introduction of [ALGOL 60](https://bliptext.com/articles/algol-60).\nBy the time he moved to Arizona, the syntax of SNOBOL4 was hopelessly outdated.\nGriswold began the effort of implementing SNOBOL's underlying success/failure concept with traditional flow control structures like if/then.\nThis became SL5, short for \"SNOBOL Language 5\", but the result was unsatisfying.\nIn 1977, he returned to the language to consider a new version.\nHe abandoned the very powerful function system introduced in SL5 with a simpler concept of suspend/resume and developed a new concept for the natural successor to SNOBOL4 with the following principles;\nThe new language was initially known as SNOBOL5, but as it was significantly different from SNOBOL in all but the underlying concept, a new name was ultimately desired.\nAfter considering \"s\" as a sort of homage to \"C\", but this was ultimately abandoned due to the problems with typesetting documents using that name.\nA series of new names were proposed and abandoned; Irving, bard, and \"TL\" for \"The Language\".\nIt was at this time that [Xerox PARC](https://bliptext.com/articles/xerox-parc) began publishing about their work on [graphical user interfaces](https://bliptext.com/articles/graphical-user-interface) and the term \"icon\" began to enter the computer lexicon.\nThe decision was made to change the name initially to \"icon\" before finally choosing \"Icon\".\n\n# Language\n\n## Basic syntax\nThe Icon language is derived from the [ALGOL](https://bliptext.com/articles/algol)-class of [structured programming](https://bliptext.com/articles/structured-programming) languages, and thus has syntax similar to [C](https://bliptext.com/articles/c-programming-language) or [Pascal](https://bliptext.com/articles/pascal-programming-language).\nIcon is most similar to Pascal, using := syntax for assignments, the procedure keyword and similar syntax.\nOn the other hand, Icon uses C-style braces for structuring execution groups, and programs start by running a procedure called main.\nIn many ways Icon also shares features with most [scripting languages](https://bliptext.com/articles/scripting-language) (as well as [SNOBOL](https://bliptext.com/articles/snobol) and SL5, from which they were taken): variables do not have to be declared, types are cast automatically, and numbers can be converted to strings and back automatically.\nAnother feature common to many scripting languages, but not all, is the lack of a line-ending character; in Icon, lines that do not end with a semicolon get ended by an implied semicolon if it makes sense.\nProcedures are the basic building blocks of Icon programs.\nAlthough they use Pascal naming, they work more like C functions and can return values; there is no function keyword in Icon.\n\n## Goal-directed execution\nOne of the key concepts in SNOBOL was that its functions returned the \"success\" or \"failure\" as primitives of the language rather than using [magic numbers](https://bliptext.com/articles/magic-number-programming) or other techniques.\nFor instance, a function that returns the position of a substring within another string is a common routine found in most language [runtime systems](https://bliptext.com/articles/runtime-system); in [JavaScript](https://bliptext.com/articles/javascript) one might want to find the position of the word \"World\" within a [\"Hello, World!\" program](https://bliptext.com/articles/hello-world-program), which would be done with icon, which would return 7.\nIf one instead asks for the icon the code will \"fail\", as the search term does not appear in the string.\nIn JavaScript, as in most languages, this will be indicated by returning a magic number, in this case -1.\nIn SNOBOL a failure of this sort returns a special value, fail.\nSNOBOL's syntax operates directly on the success or failure of the operation, jumping to labelled sections of the code without having to write a separate test.\nFor instance, the following code prints \"Hello, world!\"\nfive times:\nTo perform the loop, the less-than-or-equal operator, LE, is called on the index variable I, and if it Succeeds, meaning I is less than 5, it branches to the named label LOOP and continues.\nIcon retained the concept of flow control based on success or failure but developed the language further.\nOne change was the replacement of the labelled GOTO-like branching with block-oriented structures in keeping with the [structured programming](https://bliptext.com/articles/structured-programming) style that was sweeping the computer industry in the late 1960s.\nThe second was to allow \"failure\" to be passed along the call chain so that entire blocks will succeed or fail as a whole.\nThis is a key concept of the Icon language.\nWhereas in traditional languages one would have to include code to test the success or failure based on [Boolean logic](https://bliptext.com/articles/boolean-logic) and then branch based on the outcome, such tests and branches are inherent to Icon code and do not have to be explicitly written.\nFor instance, consider this bit of code written in the [Java programming language](https://bliptext.com/articles/java-programming-language).\nIt calls the function read to read a character from a (previously opened) file, assigns the result to the variable a, and then writes the value of a to another file.\nThe result is to copy one file to another.\nread will eventually run out of characters to read from the file, potentially on its very first call, which would leave a in an undetermined state and potentially cause write to cause a [null pointer exception](https://bliptext.com/articles/null-pointer-exception).\nTo avoid this, read returns the special value EOF (end-of-file) in this situation, which requires an explicit test to avoid writeing it:\nIn contrast, in Icon the read function returns a line of text or &fail.\n&fail is not simply an analog of EOF, as it is explicitly understood by the language to mean \"stop processing\" or \"do the fail case\" depending on the context.\nThe equivalent code in Icon is:\nThis means, \"as long as read does not fail, call write, otherwise stop\".\nThere is no need to specify a test against the magic number as in the Java example, this is implicit, and the resulting code is simplified.\nBecause success and failure are passed up through the call chain, one can embed function calls within others and they stop when the nested function call fails.\nFor instance, the code above can be reduced to:\nIn this version, if the read call fails, the write call fails, and the while stops.\nIcon's branching and looping constructs are all based on the success or failure of the code inside them, not on an arbitrary Boolean test provided by the programmer.\nif performs the then block if its \"test\" returns a value, and performs the else block or moves to the next line if it returns &fail.\nLikewise, while continues calling its block until it receives a fail.\nIcon refers to this concept as **goal-directed execution**.\nIt is important to contrast the concept of success and failure with the concept of an [exception](https://bliptext.com/articles/exception-handling); [exception](https://bliptext.com/articles/exception-handling)s are unusual situations, not expected outcomes.\nFails in Icon are expected outcomes; reaching the end of a file is an expected situation and not an exception.\nIcon does not have exception handling in the traditional sense, although fail is often used in exception-like situations.\nFor instance, if the file being read does not exist, read fails without a special situation being indicated.\nIn traditional language, these \"other conditions\" have no natural way of being indicated; additional magic numbers may be used, but more typically exception handling is used to \"throw\" a value.\nFor instance, to handle a missing file in the Java code, one might see:\nThis case needs two comparisons: one for EOF and another for all other errors.\nSince Java does not allow exceptions to be compared as logic elements, as under Icon, the lengthy try/catch syntax must be used instead.\nTry blocks also impose a performance penalty even if no exception is thrown, a [distributed cost](https://bliptext.com/articles/distributed-cost) that Icon normally avoids.\nIcon uses this same goal-directed mechanism to perform traditional Boolean tests, although with subtle differences.\nA simple comparison like if a .\nFor instance, consider some code that is attempting to find a pattern string within a larger string:\nThis code begins by moving i to 10, the starting location for the search.\nHowever, if the find fails, the block will fail as a whole, which results in the value of i being left at 10 as an undesirable [side effect](https://bliptext.com/articles/side-effect-computer-science).\nReplacing i := 10 with i x will evaluate and return x if the value of x is less than 5, or else fail.\nHowever, Icon also includes the concept of procedures that do not immediately return success or failure, and instead return new values every time they are called.\nThese are known as generators, and are a key part of the Icon language.\nWithin the parlance of Icon, the evaluation of an expression or function produces a result sequence.\nA result sequence contains all the possible values that can be generated by the expression or function.\nWhen the result sequence is exhausted, the expression or function fails.\nIcon allows any procedure to return a single value or multiple values, controlled using the fail, return and suspend keywords.\nA procedure that lacks any of these keywords returns &fail, which occurs whenever execution runs to the end of a procedure.\nFor instance:\nCalling f(5) will return 1, but calling f(-1) will return &fail.\nThis can lead to non-obvious behavior, for instance, write(f(-1)) will output nothing because f fails and suspends operation of write.\nConverting a procedure to be a generator uses the suspend keyword, which means \"return this value, and when called again, start execution at this point\".\nIn this respect it is something like a combination of the [static](https://bliptext.com/articles/static-keyword) concept in C and return.\nFor instance:\ncreates a generator that returns a series of numbers starting at i and ending a j, and then returns &fail after that.\nThe suspend i stops execution and returns the value of i without reseting any of the state.\nWhen another call is made to the same function, execution picks up at that point with the previous values.\nIn this case, that causes it to perform i +:= 1, loop back to the start of the while block, and then return the next value and suspend again.\nThis continues until i <= j fails, at which point it exits the block and calls fail.\nThis allows [iterators](https://bliptext.com/articles/iterator) to be constructed with ease.\nAnother type of generator-builder is the alternator, which looks and operates like the Boolean or operator.\nFor instance:\nThis appears to say \"if y is smaller than x or 5 then...\", but is actually a short-form for a generator that returns values until it falls off the end of the list.\nThe values of the list are \"injected\" into the operations, in this case, <.\nSo in this example, the system first tests y < x, if x is indeed larger than y it returns the value of x, the test passes, and the value of y is written out in the then clause.\nHowever, if x is not larger than y it fails, and the alternator continues, performing y < 5.\nIf that test passes, y is written.\nIf y is smaller than neither x or 5, the alternator runs out of tests and fails, the if fails, and the write is not performed.\nThus, the value of y will appear on the console if it is smaller than x or 5, thereby fulfilling the purpose of a Boolean or.\nFunctions will not be called unless evaluating their parameters succeeds, so this example can be shortened to:\nInternally, the alternator is not simply an or and one can also use it to construct arbitrary lists of values.\nThis can be used to iterate over arbitrary values, like:\nAs lists of integers are commonly found in many programming contexts, Icon also includes the to keyword to construct ad hoc integer generators:\nwhich can be shortened:\nIcon is not strongly typed, so the alternator lists can contain different types of items:\nThis writes 1, \"hello\" and maybe 5 depending on the value of x.\nLikewise the conjunction operator, &, is used in a fashion similar to a Boolean and operator:\nThis code calls ItoJ and returns an initial value of 0 which is assigned to x. It then performs the right-hand side of the conjunction, and since x % 2 does equal 0, it writes out the value.\nIt then calls the ItoJ generator again which assigns 1 to x, which fails the right-hand-side and prints nothing.\nThe result is a list of every even integer from 0 to 10.\nThe concept of generators is particularly useful and powerful when used with string operations, and is a major underlying basis for Icon's overall design.\nConsider the indexOf operation found in many languages; this function looks for one string within another and returns an index of its location, or a magic number if it is not found.\nFor instance:\nThis will scan the string s, find the first occurrence of \"the\", and return that index, in this case 4.\nThe string, however, contains two instances of the string \"the\", so to return the second example an alternate syntax is used:\nThis tells it to scan starting at location 5, so it will not match the first instance we found previously.\nHowever, there may not be a second instance of \"the\" -there may not be a first one either- so the return value from indexOf has to be checked against the magic number -1 which is used to indicate no matches.\nA complete routine that prints out the location of every instance is:\nIn Icon, the equivalent find is a generator, so the same results can be created with a single line:\nOf course there are times where one does want to find a string after some point in input, for instance, if scanning a text file that contains a line number in the first four columns, a space, and then a line of text.\nGoal-directed execution can be used to skip over the line numbers:\nThe position will only be returned if \"the\" appears after position 5; the comparison will fail otherwise, pass the fail to write, and the write will not occur.\nThe every operator is similar to while, looping through every item returned by a generator and exiting on failure:\nThere is a key difference between every and while; while re-evaluates the first result until it fails, whereas every fetches the next value from a generator.\nevery actually injects values into the function in a fashion similar to blocks under [Smalltalk](https://bliptext.com/articles/smalltalk).\nFor instance, the above loop can be re-written this way:\nIn this case, the values from i to j will be injected into someFunction and (potentially) write multiple lines of output.\n\n## Collections\nIcon includes several [collection types](https://bliptext.com/articles/collection-abstract-data-type) including [lists](https://bliptext.com/articles/list-abstract-data-type) that can also be used as [stacks](https://bliptext.com/articles/stack-abstract-data-type) and [queues](https://bliptext.com/articles/queue-abstract-data-type), [tables](https://bliptext.com/articles/associative-array) (also known as maps or dictionaries in other languages), [sets](https://bliptext.com/articles/set-abstract-data-type) and others.\nIcon refers to these as structures.\nCollections are inherent generators and can be easily called using the bang syntax.\nFor instance:\nUsing the fail propagation as seen in earlier examples, we can combine the tests and the loops:\nBecause the list collection is a generator, this can be further simplified with the bang syntax:\nIn this case, the bang in write causes Icon to return a line of text one by one from the array and finally fail at the end.\n&input is a generator-based analog of read that reads a line from [standard input](https://bliptext.com/articles/standard-input), so !&input continues reading lines until the file ends.\nAs Icon is typeless, lists can contain any different types of values:\nThe items can included other structures.\nTo build larger lists, Icon includes the list generator; generates a list containing 10 copies of \"word\".\nLike arrays in other languages, Icon allows items to be looked up by position, e.g.,.\n[Array slicing](https://bliptext.com/articles/array-slicing) is included, allowing new lists to be created out of the elements of other lists, for instance, aCat := Cats[2:4] produces a new list called aCat that contains \"tabby\" and 2002.\nTables are essentially lists with arbitrary index keys rather than integers:\nThis code creates a table that will use zero as the default value of any unknown key.\nIt then adds two items into the table, with the keys \"there\" and \"here\", and values 1 and 2.\nSets are also similar to lists but contain only a single member of any given value.\nIcon includes the ++ to produce the union of two sets, ** the intersection, and -- the difference.\nIcon includes a number of pre-defined \"Cset\"s, a set containing various characters.\nThere are four standard Csets in Icon, &ucase, &lcase, &letters, and &digits.\nNew Csets can be made by enclosing a string in single quotes, for instance, vowel := 'aeiou'.\n\n## Strings\nIn Icon, strings are lists of characters.\nAs a list, they are generators and can thus be iterated over using the bang syntax:\nWill print out each character of the string on a separate line.\nSubstrings can be extracted from a string by using a range specification within brackets.\nA range specification can return a point to a single character, or a [slice](https://bliptext.com/articles/array-slicing) of the string.\nStrings can be indexed from either the right or the left.\nPositions within a string are defined to be **between** the characters 1A2B3C4 and can be specified from the right −3A−2B−1C0\nFor example,\nWhere the last example shows using a length instead of an ending position\nThe subscripting specification can be used as a [lvalue](https://bliptext.com/articles/value-computer-science) within an expression.\nThis can be used to insert strings into another string or delete parts of a string.\nFor example:\n\n## String scanning\nA further simplification for handling strings is the scanning system, invoked with ?, which calls functions on a string:\nIcon refers to the left-hand-side of the ?\nas the subject, and passes it into string functions.\nRecall the find takes two parameters, the search text as parameter one and the string to search in parameter two.\nUsing ?\nthe second parameter is implicit and does not have to be specified by the programmer.\nIn the common cases when multiple functions are being called on a single string in sequence, this style can significantly reduce the length of the resulting code and improve clarity.\nIcon function signatures identify the subject parameter in their definitions so the parameter can be [hoisted](https://bliptext.com/articles/loop-invariant-code-motion) in this fashion.\nThe ?\nis not simply a form of syntactic sugar, it also sets up a \"string scanning environment\" for any following string operations.\nThis is based on two internal variables, &subject and &pos; &subject is simply a pointer to the original string, while &pos is the current position within it, or cursor.\nIcon's various string manipulation procedures use these two variables so they do not have to be explicitly supplied by the programmer.\nFor example:\nwould produce:\nBuilt-in and user-defined functions can be used to move around within the string being scanned.\nAll of the built-in functions will default to &subject and &pos to allow the scanning syntax to be used.\nThe following code will write all blank-delimited \"words\" in a string:\nThere are a number of new functions introduced in this example.\npos returns the current value of &pos.\nIt may not be immediately obvious why one would need this function and not simply use the value of &pos directly; the reason is that &pos is a variable and thus cannot take on the value &fail, which the procedure pos can.\nThus pos provides a lightweight wrapper on &pos that allows Icon's goal-directed flow control to be easily used without having to provide hand-written Boolean tests against &pos.\nIn this case, the test is \"is &pos zero\", which, in the odd numbering of Icon's string locations, is the end of the line.\nIf it is not zero, pos returns &fail, which is inverted with the not and the loop continues.\nmany finds one or more examples of the provided Cset parameter starting at the current &pos.\nIn this case, it is looking for space characters, so the result of this function is the location of the first non-space character after &pos.\ntab moves &pos to that location, again with a potential &fail in case, for instance, many falls off the end of the string.\nupto is essentially the reverse of many; it returns the location immediately prior to its provided Cset, which the example then sets the &pos to with another tab.\nAlternation is used to also stop at the end of a line.\nThis example can be made more robust through the use of a more appropriate \"word breaking\" Cset which might include periods, commas and other punctuation, as well as other whitespace characters like tab and non-breaking spaces.\nThat Cset can then be used in many and upto.\nA more complex example demonstrates the integration of generators and string scanning within the language.\n\n# Criticisms\nLaurence Tratt wrote a paper on Icon examining its real-world applications and pointing out a number of areas of concern.\nAmong these were a number of practical decisions that derive from their origins in string processing but do not make as much sense in other areas.\nAmong them:\nThe decision to fail by default at the end of procedures makes sense in the context of generators, but less so in the case of general procedures.\nReturning to the example noted above, write(f(-1)) will not output which may be expected.\nHowever:\nwill result in 10 being printed.\nThis sort of issue is not at all obvious as even in an interactive debugger all the code is invoked yet x never picks up the expected value.\nThis could be dismissed as one of those \"gotchas\" that programmers have to be aware of in any language, but Tratt examined a variety of Icon programs and found that the vast majority of procedures are not generators.\nThis means that Icon's default behaviour is only used by a tiny minority of its constructs, yet represents a major source of potential errors in all the others.\nAnother issue is the lack of a Boolean data type and conventional Boolean logic.\nWhile the success/fail system works in most cases where the ultimate goal is to check a value, this can still lead to some odd behaviour in seemingly simple code:\nThis program will print \"taken\".\nThe reason is that the test, c, does return a value; that value is &null, the default value for all otherwise uninitiated variables.\n&null is a valid value, so if c succeeds.\nTo test this, one needs to make the test explicit,.\nTratt supposed that it detracts from the self-documenting code, having supposed erroneously that it is testing \"is c zero\" or \"does c exist\".\n\n# Citations","revisionCount":0},"hasMore":false,"nextCursor":null}