Search results

split :: Pattern -> String -> Array String

Returns the substrings of the second string separated along occurences of the first string.

split (Pattern " ") "hello world" == ["hello", "world"]

split :: Regex -> String -> Array String

Split the string into an array of substrings along occurrences of the Regex.

split :: forall f a b x. (a -> x) -> (x -> b) -> f x -> Split f a b

Split :: forall v k. (Maybe v) -> (Map k v) -> (Map k v) -> Split k v

split :: forall m. MonadEffect m => Pattern -> Pipe (Maybe String) (Maybe String) m Unit

Accumulate string chunks until pat is seen, then yield the buffered string up to (and not including) the pattern.

When end-of-stream is reached, yields the remaining buffered string then Nothing.

toList $ yield "foo,bar,baz" >-> split ","
-- "foo" : "bar" : "baz" : Nil

Split :: forall f a. (f a) -> a -> (f a) -> Split f a

split :: forall a v. Monoid v => Measured a v => Partial => (v -> Boolean) -> FingerTree v a -> Tuple (Lazy (FingerTree v a)) (Lazy (FingerTree v a))

Split a finger tree according to which elements satisfy a predicate. This function is partial because it requires that the result of applying the predicate to mempty is false; if this is not the case, the behaviour is undefined.

A value of type @Split m@ is either a single @m@, or a pair of

Split :: forall m. m -> m -> Split m

split :: forall m. Monoid m => Split m

A convenient name for @mempty :| mempty@, so @M a <> split <>

split :: forall a. BusRW a -> Tuple (BusR a) (BusW a)

Splits a bidirectional Bus into separate read and write Buses.

split :: forall a. (a -> Boolean) -> Stream a -> { fail :: Stream a, pass :: Stream a }

Takes a predicate and a stream. A record of to streams is returned. The first stream includes all occurrences from the original stream which pass the predicate test and the second stream includes all occurrences which fail to pass the predicate.

{ pass: smallNumbers, fail: largeNumbers } = split (_ < 100) streamOfNumbers

split :: forall d c b a. Iso a b -> Iso c d -> Iso (Tuple a c) (Tuple b d)

The product type constructor Tuple is a bifunctor from Iso x Iso to Iso, so that we have the bifunctorial map *** which allows two separate isomorphisms to work on the two components of a tuple.

split :: forall a. Channel a -> Tuple (Input a) (Output a)

split :: forall action state2 state1 props. Prism' state1 state2 -> Spec state2 props action -> Spec state1 props action

Create a component which renders an optional subcomponent.

Split :: Split -> MathboxPrimitive

split :: forall f a. Applicative f => f a -> f (f a)

split :: P5 -> String -> String -> (Array String)

p5js.org documentation

split :: forall op r t s a u. Op op => Pattern u a (Tuple s t) -> (s -> t -> r) -> op u a r

Split a functor into a Day convolution. This is an implementation detail of the lowerOf function.

Split :: forall f g r. (f ~> g ⊗ r) -> Split r f g

split :: forall str a. SodiumStream str => str (Array a) -> Stream a

Push each event in the list onto a newly created transaction guaranteed to come before the next externally initiated transaction. Note that the semantics are such that two different invocations of split() can put events into the same new transaction, so the resulting stream's events could be simultaneous with events output by split() or 'defer' invoked elsewhere in the code.

Purescript port of byorgey/split

split :: SMGen -> Tuple SMGen SMGen

Split a generator into a two uncorrelated generators.

split' :: forall r t s a u. Pattern u a (Tuple s t) -> (s -> t -> r) -> Pattern u a r

split2 :: forall a s. Supply s a -> Tuple (Supply s a) (Supply s a)

Split a supply into two different supplies.

split3 :: forall a s. Supply s a -> Tuple3 (Supply s a) (Supply s a) (Supply s a)

Split a supply into three different supplies.

split4 :: forall a s. Supply s a -> Tuple4 (Supply s a) (Supply s a) (Supply s a) (Supply s a)

Split a supply into four different supplies.

splitAt :: forall a. Int -> Array a -> { after :: Array a, before :: Array a }

Splits an array into two subarrays, where before contains the elements up to (but not including) the given index, and after contains the rest of the elements, from that index on.

>>> splitAt 3 [1, 2, 3, 4, 5]
{ before: [1, 2, 3], after: [4, 5] }

Thus, the length of (splitAt i arr).before will equal either i or length arr, if that is shorter. (Or if i is negative the length will be 0.)

splitAt 2 ([] :: Array Int) == { before: [], after: [] }
splitAt 3 [1, 2, 3, 4, 5] == { before: [1, 2, 3], after: [4, 5] }

splitAt :: forall a. Int -> NonEmptyArray a -> { after :: Array a, before :: Array a }

splitAt :: Int -> String -> { after :: String, before :: String }

Splits a string into two substrings, where before contains the code points up to (but not including) the given index, and after contains the rest of the string, from that index on.

>>> splitAt 3 "b 𝐀𝐀 c 𝐀"
{ before: "b 𝐀", after: "𝐀 c 𝐀" }

Thus the length of (splitAt i s).before will equal either i or length s, if that is shorter. (Or if i is negative the length will be 0.)

In code:

length (splitAt i s).before == min (max i 0) (length s)
(splitAt i s).before <> (splitAt i s).after == s
splitAt i s == {before: take i s, after: drop i s}

splitAt :: Int -> String -> { after :: String, before :: String }

Splits a string into two substrings, where before contains the characters up to (but not including) the given index, and after contains the rest of the string, from that index on.

splitAt 2 "Hello World" == { before: "He", after: "llo World"}
splitAt 10 "Hi" == { before: "Hi", after: ""}

Thus the length of (splitAt i s).before will equal either i or length s, if that is shorter. (Or if i is negative the length will be 0.)

In code:

length (splitAt i s).before == min (max i 0) (length s)
(splitAt i s).before <> (splitAt i s).after == s
splitAt i s == {before: take i s, after: drop i s}

splitAt :: Int -> NonEmptyString -> { after :: Maybe NonEmptyString, before :: Maybe NonEmptyString }

splitAt :: Int -> NonEmptyString -> { after :: Maybe NonEmptyString, before :: Maybe NonEmptyString }

Returns the substrings of a split at the given index, if the index is within bounds.

splitAt 2 (NonEmptyString "Hello World") == Just { before: Just (NonEmptyString "He"), after: Just (NonEmptyString "llo World") }
splitAt 10 (NonEmptyString "Hi") == Nothing

Split the Vect into two sub vectors before and after, where before contains up to m elements.

vect :: Vect 10 String
vect = replicate (term :: _ 10) "a"

split ::
  { after :: Vect 7 String
  , before :: Vect 3 String
  }
split = splitAt (term :: _ 3) vect

splitAt :: forall m n m_plus_n elem. SplitAt Vect m n m_plus_n elem

Split the Vect into two sub vectors before and after, where before contains up to m elements.

vect :: Vect 10 String
vect = replicate (Common.term :: _ 10) "a"

split ::
  { after :: Vect 7 String
  , before :: Vect 3 String
  }
split = splitAt (Common.term :: _ 3) vect

splitAt :: forall m n m_plus_n elem. SplitAt MinLenVect m n m_plus_n elem

Split the MinLenVect into two sub minLenVectors before and after, where before contains up to m elements.

minLenVect :: MinLenVect 10 String
minLenVect = replicate (Common.term :: _ 10) "a"

split ::
  { after :: MinLenVect 7 String
  , before :: MinLenVect 3 String
  }
split = splitAt (Common.term :: _ 3) minLenVect

splitAt :: forall m n m_plus_n elem. SplitAt Vect m n m_plus_n elem

Split the Vect into two sub vectors before and after, where before contains up to m elements.

vect :: Vect 10 String
vect = replicate (Common.term :: _ 10) "a"

split ::
  { after :: Vect 7 String
  , before :: Vect 3 String
  }
split = splitAt (Common.term :: _ 3) vect

splitAt :: forall m n m_plus_n elem. SplitAt Vect m n m_plus_n elem

Split the Vect into two sub vectors before and after, where before contains up to m elements.

vect :: Vect 10 String
vect = replicate (Common.term :: _ 10) "a"

split ::
  { after :: Vect 7 String
  , before :: Vect 3 String
  }
split = splitAt (Common.term :: _ 3) vect

splitAt :: forall a. Int -> Seq a -> Tuple (Seq a) (Seq a)

O(log(min(i,n-i))). Split the sequence into two subsequences. The first subsequence will have i elements (unless there are not that many in the whole sequence, in which case the first element is the same sequence, unchanged).

splitAt :: forall a. Int -> Seq a -> Tuple (Seq a) (Seq a)

O(log(min(i,n-i))). Split the sequence into two (possibly empty) subsequences. The first subsequence will have i elements (unless there are not that many in the whole sequence, in which case the first element is the same sequence, unchanged).

splitOn :: forall a. (a -> Boolean) -> Array a -> Maybe { after :: Array a, before :: Array a, found :: a }

Finds a single element and returns it together with elements before and after.

partitionSides (_ == 3) [1,2,3,4,5] == Just {before: [1,2], found: 3, after: [4,5]}

splitOn :: forall a. (a -> Boolean) -> Array a -> Maybe { after :: Array a, before :: Array a, found :: a }

Finds a single element and returns it together with elements before and after.

partitionSides (_ == 3) [1,2,3,4,5] == Just {before: [1,2], found: 3, after: [4,5]}

splitCap :: forall a. String -> Parser String a -> NonEmptyList (Either String a)

Split on and capture all patterns

Find all occurences of the pattern parser sep, split the input String, capture all the matched patterns and the splits.

This function can be used instead of Data.String.Common.split or Data.String.Regex.split or Data.String.Regex.match or Data.String.Regex.search.

The input string will be split on every leftmost non-overlapping occurence of the pattern sep. The output list will contain the parsed result of input string sections which match the sep pattern in Right a, and non-matching sections in Left String.

Access the matched section of text

To capture the matched strings combine the pattern parser sep with the match combinator.

With the matched strings, we can reconstruct the input string. For all input, sep, if

let output = splitCap input (match sep)

then

input == fold (either identity fst <$> output)

Example

Split the input string on all Int pattern matches.

splitCap "hay 1 straw 2 hay" intDecimal

Result:

[Left "hay ", Right 1, Left " straw ", Right 2, Left " hay"]

Example

Find the beginning positions of all pattern matches in the input.

catMaybes $ hush <$> splitCap ".𝝺...\n...𝝺." (position <* string "𝝺")

Result:

[ Position {index: 1, line: 1, column: 2 }
, Position { index: 9, line: 2, column: 4 }
]

Example

Find groups of balanced nested parentheses. This pattern is an example of a “context-free” grammar, a pattern that can't be expressed by a regular expression. We can express the pattern with a recursive parser.

balancedParens :: Parser String Unit
balancedParens = do
  void $ char '('
  void $ manyTill (balancedParens <|> void anyCodePoint) (char ')')

rmap fst <$> splitCap "((🌼)) (()())" (match balancedParens)

Result:

[Right "((🌼))", Left " ", Right "(()())"]

splitText :: Int -> Text -> Effect Text

splitCapT :: forall m a. Monad m => MonadRec m => String -> ParserT String m a -> m (NonEmptyList (Either String a))

Monad transformer version of splitCap. The sep parser will run in the monad context.

Example

Count the pattern matches.

Parse in a State monad to remember state in the parser. This stateful letterCount parser counts the number of pattern matches which occur in the input, and also tags each match with its index.

letterCount :: ParserT String (State Int) (Tuple Char Int)
letterCount = do
  x <- letter
  i <- modify (_+1)
  pure (x /\ i)

flip runState 0 $ splitCapT "A B" letterCount

Result:

[Right ('A' /\ 1), Left " ", Right ('B' /\ 2)] /\ 2

splitName :: forall n. Name n -> { ext :: Maybe NonEmptyString, name :: NonEmptyString }

Splits Name in name and extension part.

splitName (Name ".foo")    == { name: ".foo", extension: Nothing }
splitName (Name "foo.")    == { name: "foo.", extension: Nothing }
splitName (Name "foo")     == { name: "foo",  extension: Nothing }
splitName (Name ".")       == { name: ".",    extension: Nothing }
splitName (Name "foo.baz") == { name: "foo",  extension: Just "baz" }

Note, in real code all strings from this examples would be NonEmptyString.

Also for any Name this property holds:

joinName <<< splitName = id

see joinName.

splitTree :: forall a v. Monoid v => Measured a v => Partial => (v -> Boolean) -> v -> FingerTree v a -> LazySplit (FingerTree v) a

This function throws an error if the argument is empty.

splitArea :: forall m i. Monad m => (CommandsT SplitAreaI m) ~> (CommandsT (splitArea :: I | i) m)

splitLine :: forall m i. Monad m => (CommandsT SplitLineI m) ~> (CommandsT (splitLine :: I | i) m)

splitLine :: Editor -> Effect Unit

splitSeed :: Seed -> Tuple Seed Seed

Splits a random number generator in to two.

splitToJs :: Split -> JsSplit

splitDigit :: forall a v. Monoid v => Measured a v => (v -> Boolean) -> v -> Digit a -> Split Array a

splitEmoji :: String -> Either ErrorMsg (Array String)

Split emojis into emoji array

splitLines :: String -> Array String

splitRoman :: String -> Array String

splitChoice :: forall p a b c d. Semigroupoid p => Choice p => p a b -> p c d -> p (Either a c) (Either b d)

Compose a value acting on a sum from two values, each acting on one of the components of the sum.

Specializing (+++) to function application would look like this:

(+++) :: forall a b c d. (a -> b) -> (c -> d) -> (Either a c) -> (Either b d)

We take two functions, f and g, and we transform them into a single function which takes an Eitherand maps f over the left side and g over the right side. Just like bi-map would do for the bi-functor instance of Either.

splitStrong :: forall p a b c d. Semigroupoid p => Strong p => p a b -> p c d -> p (Tuple a c) (Tuple b d)

Compose a value acting on a Tuple from two values, each acting on one of the components of the Tuple.

Specializing (***) to function application would look like this:

(***) :: forall a b c d. (a -> b) -> (c -> d) -> (Tuple a c) -> (Tuple b d)

We take two functions, f and g, and we transform them into a single function which takes a Tuple and maps f over the first element and g over the second. Just like bi-map would do for the bi-functor instance of Tuple.

splitNumber :: forall m i. Monad m => Int -> DSL (splitNumber :: I | i) m

splitEmoji' :: String -> Either ErrorMsg (List String)

Split emojis into emoji list

splitTokens :: P5 -> String -> (Maybe String) -> (Array String)

p5js.org documentation

splitByDimension :: DerivedUnit -> List (Tuple DerivedUnit DerivedUnit)

Split up a physical unit into several parts that belong to the same physical dimension (length, time, ...). In the first component, the returned tuples contain a 'target' unit, to which this group can be converted. In the second component, the original group is returned.

splitOnDoubleDash :: Option MinimistOptions Boolean

When true, all options appearing after -- will be placed into -- instead of _ in the result mapping

splitComplementary :: Color -> Array Color

The given color and two complementary colors, split by 30°.

splitTextToColumns :: Range -> Effect Unit

Splits a column of text into multiple columns based on an auto-detected delimiter.

splitIntoSubNetworks_ :: forall _l n _e _v. LayoutNetwork _l n _e _v => n -> Effect (List_ n)

splitStringEscapeLines :: String -> Array String

splitTextToColumnsWithString :: String -> Range -> Effect Unit

Splits a column of text into multiple columns using the specified string as a custom delimiter.

splitTextToColumnsWithTexttocolumnsdelimiter :: Unit