Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. map' :: Expr -> Expr -> Expr

   code-conjure	Conjure.Engine

   map lifted over Exprs.

   > map' absE (unit one)
   map abs [1] :: [Int]
   

2. mapConsts :: (Expr -> Expr) -> Expr -> Expr

   code-conjure	Conjure.Engine

   O(n*m). Applies a function to all terminal constants in an expression. Given that:

   > let one   = val (1 :: Int)
   > let two   = val (2 :: Int)
   > let xx -+- yy = value "+" ((+) :: Int->Int->Int) :$ xx :$ yy
   > let intToZero e = if typ e == typ zero then zero else e
   

   Then:

   > one -+- (two -+- xx)
   1 + (2 + x) :: Int
   

   > mapConsts intToZero (one -+- (two -+- xx))
   0 + (0 + x) :: Integer
   

   Given that the argument function is O(m), this function is O(n*m).

3. mapE :: Expr

   code-conjure	Conjure.Engine

   map over the Int element type encoded as an Expr

   > mapE
   map :: (Int -> Int) -> [Int] -> [Int]
   

4. mapSubexprs :: (Expr -> Maybe Expr) -> Expr -> Expr

   code-conjure	Conjure.Engine

   O(n*m). Substitute subexpressions of an expression using the given function. Outer expressions have more precedence than inner expressions. (cf. //) With:

   > let xx = var "x" (undefined :: Int)
   > let yy = var "y" (undefined :: Int)
   > let zz = var "z" (undefined :: Int)
   > let plus = value "+" ((+) :: Int->Int->Int)
   > let times = value "*" ((*) :: Int->Int->Int)
   > let xx -+- yy = plus :$ xx :$ yy
   > let xx -*- yy = times :$ xx :$ yy
   

   > let pluswap (o :$ xx :$ yy) | o == plus = Just $ o :$ yy :$ xx
   |     pluswap _                           = Nothing
   

   Then:

   > mapSubexprs pluswap $ (xx -*- yy) -+- (yy -*- zz)
   y * z + x * y :: Int
   

   > mapSubexprs pluswap $ (xx -+- yy) -*- (yy -+- zz)
   (y + x) * (z + y) :: Int
   

   Substitutions do not stack, in other words a replaced expression or its subexpressions are not further replaced:

   > mapSubexprs pluswap $ (xx -+- yy) -+- (yy -+- zz)
   (y + z) + (x + y) :: Int
   

   Given that the argument function is O(m), this function is O(n*m).

5. mapValues :: (Expr -> Expr) -> Expr -> Expr

   code-conjure	Conjure.Engine

   O(n*m). Applies a function to all terminal values in an expression. (cf. //-) Given that:

   > let zero  = val (0 :: Int)
   > let one   = val (1 :: Int)
   > let two   = val (2 :: Int)
   > let three = val (3 :: Int)
   > let xx -+- yy = value "+" ((+) :: Int->Int->Int) :$ xx :$ yy
   > let intToZero e = if typ e == typ zero then zero else e
   

   Then:

   > one -+- (two -+- three)
   1 + (2 + 3) :: Int
   

   > mapValues intToZero $ one -+- (two -+- three)
   0 + (0 + 0) :: Integer
   

   Given that the argument function is O(m), this function is O(n*m).

6. mapVars :: (Expr -> Expr) -> Expr -> Expr

   code-conjure	Conjure.Engine

   O(n*m). Applies a function to all variables in an expression. Given that:

   > let primeify e = if isVar e
   |                  then case e of (Value n d) -> Value (n ++ "'") d
   |                  else e
   > let xx = var "x" (undefined :: Int)
   > let yy = var "y" (undefined :: Int)
   > let xx -+- yy = value "+" ((+) :: Int->Int->Int) :$ xx :$ yy
   

   Then:

   > xx -+- yy
   x + y :: Int
   

   > primeify xx
   x' :: Int
   

   > mapVars primeify $ xx -+- yy
   x' + y' :: Int
   

   > mapVars (primeify . primeify) $ xx -+- yy
   x'' + y'' :: Int
   

   Given that the argument function is O(m), this function is O(n*m).

7. map' :: Expr -> Expr -> Expr

   code-conjure	Conjure.Expr

   map lifted over Exprs.

   > map' absE (unit one)
   map abs [1] :: [Int]
   

8. mapConsts :: (Expr -> Expr) -> Expr -> Expr

   code-conjure	Conjure.Expr

   O(n*m). Applies a function to all terminal constants in an expression. Given that:

   > let one   = val (1 :: Int)
   > let two   = val (2 :: Int)
   > let xx -+- yy = value "+" ((+) :: Int->Int->Int) :$ xx :$ yy
   > let intToZero e = if typ e == typ zero then zero else e
   

   Then:

   > one -+- (two -+- xx)
   1 + (2 + x) :: Int
   

   > mapConsts intToZero (one -+- (two -+- xx))
   0 + (0 + x) :: Integer
   

   Given that the argument function is O(m), this function is O(n*m).

9. mapE :: Expr

   code-conjure	Conjure.Expr

   map over the Int element type encoded as an Expr

   > mapE
   map :: (Int -> Int) -> [Int] -> [Int]
   

10. mapInnerFirstOuterLast :: (Expr -> Expr) -> Expr -> Expr

    code-conjure	Conjure.Expr

    No documentation available.

Page 281 of many | Previous | Next