Wolfram Research


Core Language & Structure

75 items

  • AbortOnMessage

    Abort an evaluation as soon as a message is generated

  • AllSameAs

    Check if all elements of a list are the same as a value

  • AppendSequence

    Append multiple items to an expression at once

  • AssociatePairs

    Convert a list of pairs into an association

  • AssociationMapAt

    Similar to MapAt but with improved behavior for nested expressions involving associations

  • BlockProtected

    Modify definitions of protected symbols and ensure that their attributes are restored

  • CacheTo

    Return a stored expression if it exists; otherwise, evaluate and store an expression

  • CheckMatch

    Verify that an evaluation output matches a given pattern and produces no errors

  • ContainsQ

    Determine whether an input expression contains one or more subexpressions (at any level) matching a given pattern

  • ContextModule

    Temporarily set $Context and $ContextPath to a unique empty context for an evaluation

  • DeclareArgumentCount

    Sets up a symbol to give an error message when called with an unexpected number of arguments

  • DefinitionData

    Store full definitions for a symbol in a compact object

  • DeleteCasesFrom

    Remove all elements from the value of a symbol that match a pattern and reset the symbol to the result

  • DirectorySize

    Find the total size of a directory

  • Discard

    Eliminates elements from a list for which a given conditional is True

  • DropWhile

    Drop elements of a list while a criterion remains true

  • ElementQ

    Test if an element is contained in a list

  • EmptyQ

    Test whether a structure can be considered empty

  • EnsureDirectory

    Ensure that a directory exists, no matter what

  • EnsureFilePath

    Create the directory for a given file if it does not already exist

  • Excise

    Remove enclosed arguments

  • FailOnMessage

    Stop an evaluation when a message is encountered and return a given failure expression

  • FullSymbolName

    Return a fully qualified name of a symbol regardless of current context settings

  • GetKeyValuePattern

    Creates a suitable KeyValuePattern from an example association

  • HoldArguments

    Construct a function from another function that holds certain arguments

  • InheritedBlock

    Similar to Block, except values of local symbols are not cleared when entering the block

  • Inline

    inserts the values of symbols into an expression before evaluation

  • JoinTo

    Equivalent to Join, but redefines the first argument to the result

  • KeyReplace

    Replace keys in an association

  • LocalEvaluate

    Synchronously evaluate an expression in a separate kernel

  • MapAtKey

    Apply functions to specific keys in an association

  • MapCases

    Map a function at parts of an expression that match a given pattern

  • MapIf

    Map a function for elements in a list when a test gives True

  • OnceUnlessFailed

    Equivalent to using Once, but will only cache results if evaluation was successful

  • OnFailure

    Apply a function on an expression when FailureQ gives True on it; otherwise, return the expression

  • Pop

    Remove and return an element of an expression

  • PositionLargest

    Get the position of the largest elements in a list

  • PositionLargestBy

    The position of the elements in a list that are largest according to a given function

  • PrefixQ

    Test if the first elements of a list are the same as those from another list

  • RandomPartChoice

    Choose random parts of an expression

  • RandomRealPoint

    Randomly choose a point within a specified domain

  • Rarest

    The rarest elements in a list

  • ReadableForm

    Display an expression in a format intended to maximize readability

  • RepeatUntil

    Evaluate an expression repeatedly until a test is satisfied

  • ReplaceAllOutside

    Similar to ReplaceAll, but parts of the expression can be ignored by providing a pattern

  • ReplaceAllUnheld

    Apply replacement rules to evaluated parts of expression

  • RootSymbol

    Recursively take the head of an expression

  • SameAsQ

    An operator form of SameQ

  • SelectFirstBy

    Apply a function to a list and select the first that satisfies a test

  • SelectFirstIndex

    Find the index of the first element satisfying a criterion

  • SelectIndices

    Find indices of parts satisfying a criterion

  • SelectPositions

    A function like Select that returns positions instead of values

  • SetTo

    Use as an operator form of Set

  • SetUnless

    Initialize a value unless it already satisfies a given condition

  • Slice

    An operator form of Part

  • SplitWhen

    Split a list every time an element satisfies a test

  • StringDisjointQ

    Test if two strings have no common characters

  • StringFunction

    Use functions meant for lists on strings

  • StringIntersectingQ

    Test if two strings have any common characters

  • StringIntersection

    Find the characters common to multiple strings

  • StringPatternQ

    Test a valid string pattern

  • StringSort

    Sort the characters in a string

  • StringUnion

    Find the distinct characters in multiple strings

  • SymbolCases

    Find symbols whose definition contains specified pattern

  • SymbolsWithAttribute

    Utility for finding and listing all symbols with a particular attribute

  • SymbolsWithOption

    Utility for finding and listing all symbols with a particular option

  • TableQ

    Similar to ArrayQ, except allows for ragged collections of nested lists

  • UnionTo

    Equivalent to Union but redefines the first argument to the result

  • UniqueCases

    Similar to Cases, but removes duplicates

  • UniqueContext

    Provide a new context that contains no symbols

  • UnsortedComplement

    Delete the elements of some lists from a list x without changing either the order of x or the multiplicities of its elements

  • Unthread

    A partial inverse for Thread

  • Until

    Similar to While, but it performs the action before the test

  • When

    An operator form of Which

  • WhenNot

    The opposite of When