transient

Remarque importante: Transient est traduit par un nouveau repo

Ce repo est obsolète

S'il vous plaît, pour la dernière version, allez à:

https://github.com/transient-haskell/transient-stack

Il y a tous les packages Haskell, y compris l'informatique distribuée (Univers transitoire) et le site Web côté client (axiom)

Remarque: L'informatique distribuée et les primitives Web sont dans l'univers transitoire et l'axiome. Quelques exemples à des exemples transitoires

Quelques commentaires sur transient :

1. Rahul Muttineni @rahulmutt nov. 09 2016 03:40 Lead DevelopperPer d'ETA (le compilateur JVM Haskell)

   C'est un peu d'esprit qui se plie en ce que c'est comme utiliser une liste de plus haut niveau, mais c'est très, très cool. Pour commencer les Haskellers, ce qui serait vraiment utile, c'est une visualisation de ce qui se passe lorsque vous faites diverses choses distribuées / parallèles. Il est presque choquant de voir à quel point vous pouvez exécuter des calculs à travers les threads / nœuds.

   La partie fraîche est la composabilité du réglage distribué. Vous pouvez faire des fonctions monadiques d'ordre supérieur qui vous permettent de composer et de réutiliser une longue chaîne de transactions distribuées via wormhole et teleport . Un autre avantage est que la transaction devient de première classe et que vous pouvez voir exactement ce qui se passe en un seul endroit au lieu de distribuer la logique entre les acteurs, ce qui rend le code équivalent aux rappels d'événements, comme vous l'avez dit.

https://gitter.im/transient-transient-universe-hplay/lobby?at=58228CAA35E6CF054773303B

Qu'est-ce qui est transitoire?

L'un des rêves de l'ingénierie logicielle est la composabilité sans restriction.

Cela peut être mis en ces termes:

Laissez ap1 et ap2 deux applications avec une complexité arbitraire, avec tous les effets comprenant plusieurs threads, IO asynchrone, indéterminisme, événements et peut-être, informatique distribué.

Puis les combinaisons:

 - ap1 <|> ap2          -- Alternative expression
 - ap1 >>= x -> ap2    -- monadic sequence
 - ap1 <> ap2           -- monoidal expression
 - (,) <$> ap1 <*> ap2  -- Applicative expression

sont possibles si les types correspondent et génèrent également de nouvelles applications composables.

Transient fait exactement cela.

Les opérateurs <$> <*> et <> expriment la concurrence, l'opérateur <|> Exprime le parallélisme et >>= pour le séquençage des threads, des processus distribués ou des widgets Web. Ainsi, même en présence de ces effets et d'autres, tout est composable.

À cet effet, le transitoire est une monade effets extensibles avec tous les effets et primitives majeurs pour le parallélisme, les événements, l'OI asynchrone, la terminaison précoce, l'exploitation de non-déterminisme et l'informatique distribuée. Puisqu'il est possible de l'étendre avec plus d'effets sans ajouter de transformateurs Monad, la composabilité est assurée.

Exemple motivant

Ce programme diffusera "Hello World" de n nœuds si vous entrez "Fire" dans la console

main = keep $ initNode $ inputNodes <|> distribStream

distribStream = do
      local $ option " fire " " fire "
      r <- clustered . local . choose $ repeat " hello world "
      localIO $ print r

Lisez le tutoriel pour savoir comment le compiler et l'invoquer.

Ce programme présentera un lien dans le navigateur et diffusera les numéros Fibonnacci au navigateur lorsque vous cliquez dessus. (Si vous avez Docker, vous pouvez le faire fonctionner à partir de la console; voir ceci

main = keep . initNode $ webFib

webFib = onBrowser $ do
    local . render $  wlink () (h1 " hello fibonacci numbers " )

    r <-  atRemote $ do
                r <- local . threads 1 . choose $ take 10 fibs
                localIO $ print r
                localIO $ threadDelay 1000000
                return r

    local . render . rawHtml $ (h2 r)
    where
    fibs = 0 : 1 : zipWith (+) fibs ( tail fibs) :: [ Int ]

Ce programme combine les deux fonctionnalités:

main = keep . initNode $ inputNodes <|> webFib <|> distribStream

Documentation

Le wiki est plus orienté vers l'utilisateur

Mes séances vidéo dans livecoding.tv ne sont pas destinées à des tutoriels ou à des présentations, mais affichent certaines des dernières fonctionnalités en cours d'exécution.

Les articles sont plus techniques:

• Philosophie, async, parallélisme, contrôle des discussions, événements, état de session
• Backtracking et annulation des transactions IO
• Liste non déterministe comme le traitement, multithreading
• Informatique distribuée
• Publier les variables de subscription
• Streaming distribué, Map-Reduce

Ces articles contiennent des exemples exécutables (pas maintenant, car le site ne prend plus en charge l'exécution des extraits Haskell).

Plans

Une fois que la composibilité dans le grand est possible, il existe une quantité infinie d'idées qui peuvent être réalisées. Il y a des objectifs à court et à long terme. Un statut de développement est régulièrement publié dans.

Parmi les plus fous, il y a la possibilité d'étendre ce cadre à d'autres langues et de les rendre interopérables. Traiter des applications emballées entières comme des composants et les amarrer comme des pièces LEGO dans une nouvelle couche du système d'exploitation où la coque permet un tel type d'amarrage sûr de type. Ce Docker composable permet toutes sortes de composibilité, tandis que la plate-forme Docker actuelle n'est qu'une forme de monoïde dégradé qui ne calcule pas.

Contribuer:

Tu veux contribuer? Assurez-vous que vous avez lu nos directives de contributeurs. Nous aimerions avoir de vos nouvelles et vos idées, contacter d'autres contributeurs:

• La page des problèmes pour transitoire

• La page des problèmes pour l'univers transitoire

• La page des problèmes pour axiome

Une fois que vous avez appris quelque chose d'intéressant, vous pouvez contribuer au wiki

Vous pouvez également faire un don au développeur principal afin de permettre le dévouement de plus de temps à Fullfil les avantages potentiels de la véritable composabilité des logiciels dans toute la pile.