The situation may occur that one has two tables, where the first one has a reference to the first one, but that reference cannot be expressed in terms of a foreign key constraint. One example may look as follows:
create table parent (id int not null, version int not null, description text not null);
alter table parent add constraint parent_pkey primary key (id, version);
if (a) false else b === !a && bif (a) true else b === a || bif (a) a else b === a || b
| <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"> | |
| <html> | |
| <head> | |
| <meta charset="UTF-8"/> | |
| <title>Titel</title> | |
| <script src='https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.7.3/Chart.bundle.min.js'></script> | |
| <link rel='stylesheet' type='text/css' href='../style.css'/> | |
| </head> |
Occasionally, one may have an operation where one needs to combine two data structures, where the full traversal is linear in the number of elements in the structure, and a query operation is logarithmic (with an arbitrary base) in the number of elements in the structure. One use case for such a combination is the definition of an intersection of maps as in Scala, where there is currently no general merge operation for this case.
If we traverse one structure while querying the other - is it cheaper (in terms of complexity) to traverse the larger one or the smaller one?
A short while ago I was contemplating the question, whether every list function is expressible in terms of an application of foldr.
The restriction is that there has to be exactly one application of foldr and no additional workarounds.
For example, creating an intermediate pair of results and returning just one of its components or preprocessing the input list [a] to a more enriched form [(a, b)] are not allowed.
Baltasar Trancón Widemann has pointed out that this is not the case and that the avg function that computes the average of a given list is a counterexample. This short text proves why this is the case.
The function we wish to define is
avg :: Fractional a => [a] -> Maybe a
| import Data.Foldable ( Foldable, foldMap ) | |
| import Data.Function ( on ) | |
| import Data.Monoid ( Monoid ( .. ) ) | |
| type Algebra f a = f a -> a | |
| newtype Mu f = Fix ( f (Mu f) ) | |
| inject :: f (Mu f) -> Mu f | |
| inject = Fix |
| {-# OPTIONS_CYMAKE -X TypeClassExtensions #-} | |
| import Constraint ( andC ) | |
| validDigits :: [Int] | |
| validDigits = [0 .. 9] | |
| solveWith :: [Int] -> [Int] | |
| solveWith vds | digits =:= zipWith numberOfIn vds (repeat digits) = digits where | |
| digits = [unknown' | _ <- vds] |