Search results

Jump to navigation Jump to search

Page title matches

  • Introduction to Haskell IO/Introduction to IO actions
    #redirect [[Introduction to Haskell IO/Actions]]
    83 bytes (11 words) - 06:49, 8 June 2023
  • Ru/IO
    ...это обычная функция, тип результата которой обёрнут в конструктор типов '''IO'''. putChar :: Char -> IO () -- выводит один символ на stdout
    25 KB (918 words) - 06:01, 1 June 2022
  • IO inside
    ...Haskellers - if that's you, a good place to start is the [[Introduction to IO]] which can help you learn the basics (e.g. the syntax of I/O expressions) data IO a = Act (Time -> (a, Time))
    82 KB (13,140 words) - 09:07, 3 May 2024
  • IO then abstraction
    The implementation of IO as a monad is the main reason you need to be comfortable with monads to be <code>IO</code> is the monad you cannot avoid.
    6 KB (940 words) - 12:17, 19 April 2024
  • Binary IO
    ...//hackage.haskell.org/package/base-4.6.0.1/docs/System-IO.html#g:21 System.IO] ...rovides byte level operations, and is used in some applications for binary IO
    2 KB (254 words) - 19:03, 23 October 2013
  • IO Semantics
    ...e are only some of the various ways to describe the semantics of </i><code>IO a</code><i>; your actual implementation may vary. (Inspired by [https://lukepalmer.wordpress.com/2008/03/29/io-monad-the-continuation-presentation Luke Palmer's post].)
    11 KB (1,628 words) - 10:36, 5 April 2024
  • Avoiding IO
    It may be possible to use a simpler, more specific type than <code>IO</code> for certain tasks. randomDist :: (Random a, Num a) => (a -> a) -> IO a
    10 KB (1,634 words) - 22:52, 6 April 2022
  • Lazy IO
    56 bytes (7 words) - 12:02, 19 April 2024
  • Iteratee IO
    61 bytes (9 words) - 06:54, 8 June 2023
  • Monada de IO
    Operatiile de IO sunt in Haskell numite actiuni si sunt de fapt niste date. Le puteti pune p
    733 bytes (114 words) - 15:19, 6 February 2021
  • IO at work
    The one chosen for Haskell is to keep the I/O of an ''action'' (<code>IO</code> computation) outside of Haskell's expression evaluation by moving it This is where the <code>IO</code> types come into play.
    8 KB (1,215 words) - 07:10, 12 June 2023
  • Namespaced IO Layer
    ...based on the ideas found in Plan 9 and Inferno, that is, to represent each IO capable resource as a virtual file server exposing a tree of files and dire Source code: http://code.google.com/p/hs-ogl-misc/source/browse/ under the io-layer directory.
    11 KB (1,853 words) - 02:34, 26 April 2021
  • Introduction to IO
    ''(This page is intended as a quick introduction to how IO is treated in Haskell. It doesn't describe everything there is to know, but particular type. Specifically, a value of type <code>(IO a)</code> is an action,
    5 KB (958 words) - 15:20, 3 August 2022
  • Ru/IO Inside
    ...реализации Haskell I/O и постепенно сделать из вас специалиста по работе с IO. Более того, я добавил детальное описание
    64 KB (6,046 words) - 11:23, 22 October 2022
  • IO, partible-style
    #redirect [[IO in action]]
    60 bytes (9 words) - 21:27, 14 June 2022
  • IO in action
    ...g for operations (actions) that interact with the outside world. The <code>IO</code> type is abstract: no constructors are visible to the user. [...] data IO -- abstract
    4 KB (674 words) - 07:12, 12 June 2023
  • IO tutorials timeline
    ...20210429180440/www.microsoft.com/en-us/research/wp-content/uploads/1995/01/io-tutorial.pdf paper], [https://www.haskell.org/haskell-workshop/1995/HW1995- ...8: Input/Output] (translations: [https://www.sampou.org/haskell/tutorial-j/io.html jp])
    8 KB (1,101 words) - 10:59, 2 May 2024
  • Blog articles/IO
    == IO == ...t.com:80/2007/02/more-on-haskell-io-and-interact.html Introductory console IO in Haskell]
    2 KB (236 words) - 07:29, 10 August 2023
  • Introduction to Haskell IO
    ...rammer who has some haskell under his belt but is not yet comfortable with IO or monads. The goal is to get the reader proficient in writing useful code # [[Introduction to Haskell IO/General introduction]]
    10 KB (1,520 words) - 07:20, 10 November 2020
  • Tutorials/ProgrammingHaskell/String IO
    #redirect [[Tutorials/Programming Haskell/String IO]]
    88 bytes (11 words) - 12:34, 8 June 2023
  • Introduction to IO actions
    #redirect [[Introduction to Haskell IO/Actions]]
    83 bytes (11 words) - 06:50, 8 June 2023
  • Introduction to Haskell IO/Actions
    of actions but we'll start with a very important one called an '''IO''' action. Here are some examples of IO actions:
    14 KB (2,254 words) - 20:41, 10 November 2020
  • Tutorials/Programming Haskell/String IO
    main :: IO () ...tp://haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html System.IO] library.
    19 KB (3,139 words) - 04:08, 22 October 2021
  • Haskell IO for Imperative Programmers
    main :: IO () processIt :: String -> IO ()
    20 KB (3,555 words) - 06:05, 24 April 2024
  • How to get rid of IO
    ...mething of type <code>a</code>, so how do I get rid of that annoying <code>IO</code> type?</i> ...so in other words, you've got e.g. <code>thatIOThingie :: IO Datum</code>, but <code>regularThingie :: Datum</code> is what the rest of
    4 KB (726 words) - 05:08, 6 April 2022
  • Cum transform o lista de actiuni de IO in actiunea-secventa a lor ?
    sequence_ :: [ IO() ] -> IO () ...actiuni de IO. Valoarea initiala pentru foldr este bineinteles actiunea de IO vida: ''return ()''
    1 KB (206 words) - 15:17, 6 February 2021
  • De ce sunt mai bune actiunile de IO decat instructiunile de I/O ?
    ...te motive. Actiunile de IO sunt mult mai flexibile decat instructiunile de IO. Intr-un limbaj de programare obisnuit, de acum doua trei decenii, compilat todolist ::[ IO () ]
    2 KB (255 words) - 15:18, 6 February 2021

Page text matches

  • IO入門編
    ...、副作用は特定の型の値としてエンコードすることで考慮されなければならない、とすることで副作用がある処理と純粋な関数を切り離してきました。<code>(IO a)</code>型の値はアクションです。これは実行されたら<co
    7 KB (299 words) - 11:39, 22 October 2022
  • Switching type classes at runtime
    throwChecked :: e -> IO a rethrowUnchecked :: forall e a. (Throws e => IO a) -> (Exception e => IO a)
    1 KB (215 words) - 10:06, 3 August 2015
  • Hakell I/Oアクションの紹介
    Haskellが扱う他の値と同様に、アクションにも型があります。多くの種類のアクションがありますが、ここでは '''IO''' アクションと呼ばれる非常に重要なアクションから始 このアクションはプログラムの外部に対して働きかけることができるアクションです。ここにIOアクションの例を示します：
    18 KB (640 words) - 03:11, 9 April 2021
  • Encoding issues
    ==IO== I/O operations should be split into two parts, binary io and string io.
    2 KB (307 words) - 13:45, 23 May 2021
  • Unsafe functions
    * <hask>unsafePerformIO :: IO a -> a</hask> * <hask>unsafeInterleaveIO :: IO a -> IO a</hask>
    1 KB (206 words) - 12:27, 8 June 2023
  • Blog articles/IO
    == IO == ...t.com:80/2007/02/more-on-haskell-io-and-interact.html Introductory console IO in Haskell]
    2 KB (236 words) - 07:29, 10 August 2023
  • Mlist
    MList is a monadic-list, aiming to be an alternative to [[Lazy IO|lazy I/O]]. ...s a list of a's whose evaluation continually requires executing actions in IO.
    427 bytes (73 words) - 12:02, 19 April 2024
  • Expanding type synonyms in error messages proposal
    import System.IO (isEOF) loop :: Producer String IO ()
    2 KB (215 words) - 09:14, 19 June 2015
  • Cum transform o lista de actiuni de IO in actiunea-secventa a lor ?
    sequence_ :: [ IO() ] -> IO () ...actiuni de IO. Valoarea initiala pentru foldr este bineinteles actiunea de IO vida: ''return ()''
    1 KB (206 words) - 15:17, 6 February 2021
  • IO, partible-style
    #redirect [[IO in action]]
    60 bytes (9 words) - 21:27, 14 June 2022
  • Tutorials/ProgrammingHaskell/String IO
    #redirect [[Tutorials/Programming Haskell/String IO]]
    88 bytes (11 words) - 12:34, 8 June 2023
  • 99 questions/Solutions/25
    rnd_permu :: [a] -> IO [a] rnd_permu :: [a] -> IO [a]
    1 KB (187 words) - 13:08, 10 May 2014
  • Formatting function types
    -> IO () -> IO ()
    2 KB (363 words) - 08:15, 23 May 2021
  • IOIntroDraft
    #redirect [[Introduction to Haskell IO]]
    75 bytes (10 words) - 06:44, 8 June 2023
  • IOIntro Actions
    #redirect [[Introduction to Haskell IO/Actions]]
    83 bytes (11 words) - 06:44, 8 June 2023
  • Introduction to IO actions
    #redirect [[Introduction to Haskell IO/Actions]]
    83 bytes (11 words) - 06:50, 8 June 2023
  • Introduction to Haskell IO/Introduction to IO actions
    #redirect [[Introduction to Haskell IO/Actions]]
    83 bytes (11 words) - 06:49, 8 June 2023
  • Cum se scrie functia main ?
    ...ine ca functie pentru citit un String. getLine chiar are tipul: getLine:: IO String. Adica este o actiune de IO care poate fi folosita pentru a lega o variabila la Stringul citit.
    3 KB (436 words) - 10:21, 29 November 2019
  • Blog articles/Parallel
    * STM and IO ** [http://mult.ifario.us/articles/2007/03/04/stm-and-io STM, IO, and a Simple Persistence Model]
    3 KB (296 words) - 15:06, 25 June 2017
  • POSIX process group API reform proposal
    getProcessGroupID :: IO ProcessGroupID getProcessGroupIDOf :: ProcessID -> IO ProcessGroupID
    2 KB (359 words) - 00:16, 17 June 2021
  • 99 questions/Solutions/24
    diff_select :: Int -> Int -> IO [Int] diffSelect :: Int -> Int -> IO [Int]
    2 KB (244 words) - 00:09, 7 April 2019
  • How to get rid of IO
    ...mething of type <code>a</code>, so how do I get rid of that annoying <code>IO</code> type?</i> ...so in other words, you've got e.g. <code>thatIOThingie :: IO Datum</code>, but <code>regularThingie :: Datum</code> is what the rest of
    4 KB (726 words) - 05:08, 6 April 2022
  • GHC/Redesign
    load :: Session -> LoadHowMuch -> IO SuccessFlag compileToBytecode :: Session -> ModSummary -> IO SuccessFlag
    3 KB (404 words) - 23:03, 11 July 2021
  • De ce sunt mai bune actiunile de IO decat instructiunile de I/O ?
    ...te motive. Actiunile de IO sunt mult mai flexibile decat instructiunile de IO. Intr-un limbaj de programare obisnuit, de acum doua trei decenii, compilat todolist ::[ IO () ]
    2 KB (255 words) - 15:18, 6 February 2021
  • UTF-8
    provides a drop-in replacement for System.IO If we use a function from System.IO.UTF8, we should also hide the equivalent one from the Prelude. (Alternative
    922 bytes (129 words) - 15:20, 6 February 2021
  • MonadPlus
    ...Left Catch''' &mdash; this is rarely advocated, but <tt>Maybe</tt> and <tt>IO</tt> satisfy this as an alternative to '''Left Distribution'''. * <hask>Maybe</hask>, <hask>IO</hask> and <hask>STM</hask> satisfy '''Monoid''', '''Left Zero''', and '''L
    2 KB (240 words) - 22:55, 5 April 2021
  • Humor/Erlkönig
    > randomRIO is IO a while the function defined by me is Int. Since I only need > randomRIO :: forall a. (Random a) => (a, a) -> IO a
    5 KB (787 words) - 11:02, 26 December 2017
  • Monad Transformers Tutorial
    Think about code in IO that needs to be able to break out of a loop: ...k" is to implement the <hask>Maybe</hask> monad again, this time, on <hask>IO (Maybe a)</hask> values instead of <hask>Maybe a</hask> values:
    5 KB (801 words) - 19:04, 8 February 2014
  • Simple RWST use
    RWST on IO example. Inspired by [[Simple_StateT_use]].<br\> IO: Get next guess from stdin.<br\>
    2 KB (237 words) - 19:47, 9 January 2018
  • Introduction to IO
    ''(This page is intended as a quick introduction to how IO is treated in Haskell. It doesn't describe everything there is to know, but particular type. Specifically, a value of type <code>(IO a)</code> is an action,
    5 KB (958 words) - 15:20, 3 August 2022
  • Applicative data-driven programming
    type Source = (,) (IO () -> IO ()) `O` IO type UI = (->) Win `O` IO `O` (,) Layout `O` Source
    3 KB (486 words) - 21:52, 29 June 2021
  • 99 questions/Solutions/23
    rnd_select :: [a] -> Int -> IO [a] rnd_selectIO :: [a] -> Int -> IO [a]
    4 KB (666 words) - 13:03, 10 May 2014
  • Yampa/reactimate
    reactimate :: IO a -- init -> (Bool -> IO (DTime, Maybe a)) -- input/sense
    5 KB (780 words) - 11:40, 6 June 2016
  • IO at work
    The one chosen for Haskell is to keep the I/O of an ''action'' (<code>IO</code> computation) outside of Haskell's expression evaluation by moving it This is where the <code>IO</code> types come into play.
    8 KB (1,215 words) - 07:10, 12 June 2023
  • Parallelism
    * [[Pure]] parallelism, which can be used to speed up non-IO parts of the program. * [[Concurrency]], which can be used for parallelising IO.
    3 KB (408 words) - 21:38, 3 May 2024
  • De unde pot invata despre Monade ?
    ==. Monada de IO == "The Haskell Programmer's Guide to the IO Monad" de Stefan Klinger.
    2 KB (349 words) - 05:56, 1 June 2022
  • IO tutorials timeline
    ...20210429180440/www.microsoft.com/en-us/research/wp-content/uploads/1995/01/io-tutorial.pdf paper], [https://www.haskell.org/haskell-workshop/1995/HW1995- ...8: Input/Output] (translations: [https://www.sampou.org/haskell/tutorial-j/io.html jp])
    8 KB (1,101 words) - 10:59, 2 May 2024
  • Yhc/RTS/Exceptions
    ...xception (including 'error') to be thrown from pure code and caught in the IO monad. catch :: IO a -> (Exception -> IO a) -> IO a
    8 KB (1,141 words) - 01:44, 14 July 2021
  • Guess a random number
    main :: IO () getSeed :: [String] -> IO Int
    5 KB (787 words) - 15:17, 6 February 2021
  • Haskell Quiz/FizzBuzz/Solution Syzygies
    main :: IO () main :: IO ()
    980 bytes (157 words) - 15:19, 6 February 2021
  • Sound data structures
    ...ask><br /><hask>mainStereo :: ((CFloat, CFloat) -> IO (CFloat, CFloat)) -> IO ()</hask>, <br /><hask>StorableArray</hask>
    3 KB (353 words) - 23:01, 29 April 2014
  • IO in action
    ...g for operations (actions) that interact with the outside world. The <code>IO</code> type is abstract: no constructors are visible to the user. [...] data IO -- abstract
    4 KB (674 words) - 07:12, 12 June 2023
  • Iteratee
    ...www.haskell.org/pipermail/haskell-cafe/2010-February/072838.html safe lazy IO or Iteratee?] ...ww.mail-archive.com/haskell-cafe@haskell.org/msg45890.html Lazy vs correct IO]
    2 KB (228 words) - 15:18, 6 February 2021
  • Binary IO
    ...//hackage.haskell.org/package/base-4.6.0.1/docs/System-IO.html#g:21 System.IO] ...rovides byte level operations, and is used in some applications for binary IO
    2 KB (254 words) - 19:03, 23 October 2013
  • Introduction to Haskell IO/Actions
    of actions but we'll start with a very important one called an '''IO''' action. Here are some examples of IO actions:
    14 KB (2,254 words) - 20:41, 10 November 2020
  • Xmonad/Config archive/David Roundy's xmonad.hs
    main :: IO ()
    148 bytes (19 words) - 15:17, 6 February 2021
  • Random shuffle
    import Data.Array.IO shuffle :: [a] -> IO [a]
    5 KB (743 words) - 13:10, 9 May 2017
  • Disposing of dismissives
    * <code>closeIORef :: IORef a -> IO ()</code> * <code>endMVar :: MVar a -> IO ()</code>
    3 KB (431 words) - 04:31, 9 June 2022
  • Fizzbuzz
    main :: IO()
    466 bytes (55 words) - 15:18, 6 February 2021
  • Blog articles
    * [[/IO|IO in Haskell]]
    2 KB (225 words) - 11:34, 27 February 2019
  • 99 questions/Solutions/68
    preInTree po@(x:xs) io = do (lio,_:rio) <- return $ break (== x) io
    2 KB (280 words) - 03:43, 10 January 2017
  • Handling errors in Haskell
    ...rarely but can happen and can be handled if needs be. Typically caused by IO going wrong in some way, like the machine running out of swap and your prog * <hask>try :: Exception e => IO a -> IO (Either e a) </hask>
    5 KB (795 words) - 08:03, 3 August 2017
  • Short examples/BF interpreter
    type BF a b = StateT (Ptr a) IO b tape <- (mallocBytes 10000 :: IO (Ptr Word8))
    2 KB (242 words) - 01:12, 26 April 2021
  • Haskell Quiz/FizzBuzz/Solution Ninju
    main :: IO ()
    546 bytes (69 words) - 15:19, 6 February 2021
  • Gtk2Hs/Tutorials/TreeView
    main :: IO () oneSelection :: ListStore String -> Model.TreeSelection -> IO ()
    2 KB (280 words) - 00:46, 9 April 2021
  • Monomorphism by annotation of type variables
    primitive newIORef :: monomo a . a -> IO (IORef a) :import Prelude(Bool, Char, Double, Either, Float, Int, IO, Integer)
    3 KB (459 words) - 08:33, 18 August 2021
  • Cookbook/Databases access
    main :: IO () rows <- query_ conn "SELECT * from t1" :: IO [(Int, String, Maybe Double, Maybe UTCTime)]
    2 KB (254 words) - 09:57, 29 March 2022
  • Stupid Curry Tricks
    ...the file "hi.txt", but it can easily be modified to interact with standard IO or read a file passed on the command line. The most interesting part is th import System.IO
    2 KB (238 words) - 15:18, 6 February 2021
  • 99 questions/Solutions/46
    ...th table; most of the complexity here comes from the string conversion and IO. The approach used here accepts a Boolean function <tt>(Bool -> Bool -> Boo table :: (Bool -> Bool -> Bool) -> IO ()
    4 KB (655 words) - 07:48, 27 April 2016
  • Merely monadic
    === <code>IO</code>, in particular === ...according to the implementation's private definition of the abstract <code>IO</code> type.
    6 KB (988 words) - 04:35, 16 March 2021
  • MonadPlus reform proposal
    ...tisfy '''Left Distribution''', while others such as <tt>Maybe</tt> and <tt>IO</tt> satisfy '''Left Catch'''. ...uestion the claim that Maybe and IO should be thought of as "left catch". IO is not even in MonadPlus, and I don't see how it can be meaningfully in any
    4 KB (609 words) - 18:22, 23 June 2015
  • FFI Introduction
    ...ole tcgetattr / tcsetattr thing, but let's just turn ICANON on and off, so IO.getChar doesn't wait for a newline: foreign import ccall "set_icanon" set_icanon :: CInt -> IO ()
    2 KB (331 words) - 12:45, 17 February 2015
  • Care sunt structurile de control in Haskell ?
    myforever :: [[IO ()]] -> [[IO ()]] <br> myrepeat :: Int -> IO a -> IO () <br>
    3 KB (436 words) - 15:16, 6 February 2021
  • Introduction to Haskell IO
    ...rammer who has some haskell under his belt but is not yet comfortable with IO or monads. The goal is to get the reader proficient in writing useful code # [[Introduction to Haskell IO/General introduction]]
    10 KB (1,520 words) - 07:20, 10 November 2020
  • Haskell Quiz/FizzBuzz/Solution Mikbe
    main :: IO ()
    536 bytes (86 words) - 15:18, 6 February 2021
  • How to work on lists
    === Lists and IO === *''Execute a list of IO actions.''
    6 KB (1,106 words) - 12:32, 15 November 2019
  • IO Semantics
    ...e are only some of the various ways to describe the semantics of </i><code>IO a</code><i>; your actual implementation may vary. (Inspired by [https://lukepalmer.wordpress.com/2008/03/29/io-monad-the-continuation-presentation Luke Palmer's post].)
    11 KB (1,628 words) - 10:36, 5 April 2024
  • Means of expression
    count :: Description -> IO (Maybe Int) openFile :: FilePath -> IO Handle
    5 KB (765 words) - 22:40, 23 April 2021
  • Comparison of functional programming languages
    | IO type + monads
    732 bytes (96 words) - 21:43, 3 May 2024
  • Exception
    Unfortunately Haskell's standard library names common exceptions of IO actions <hask>IOError</hask> Since no IO functions are involved, we still cannot handle exceptional situations induc
    10 KB (1,404 words) - 06:22, 22 January 2020
  • Iteratee I/O
    Iteratee I/O is a way to avoid the problems that can occur with [[Lazy IO|lazy I/O]]. They work by making the I/O operations explicit, making their b As a beginner, you probably used Haskell's lazy I/O through the <code>System.IO</code> module. However, while it is good enough for simple programs, its un
    4 KB (653 words) - 12:02, 19 April 2024
  • Graham Scan Implementation
    main :: IO () checkN :: Int -> IO ()
    2 KB (298 words) - 03:42, 14 August 2021
  • Concurrency demos/Zeta
    getParams :: IO (Int, Int, Complex Double) main :: IO ()
    4 KB (555 words) - 10:58, 22 June 2021
  • Examples/Random list
    ...e entire list being operated on (forcing it all into memory at once). And IO [a] cannot lazily return any initial values. unpick :: [a] -> IO [a]
    6 KB (855 words) - 12:54, 26 June 2017
  • GHC/AdvancedOverlap
    print :: a -> IO () print' :: flag -> a -> IO ()
    10 KB (1,575 words) - 13:27, 14 January 2015
  • IO then abstraction
    The implementation of IO as a monad is the main reason you need to be comfortable with monads to be <code>IO</code> is the monad you cannot avoid.
    6 KB (940 words) - 12:17, 19 April 2024
  • Monada de IO
    Operatiile de IO sunt in Haskell numite actiuni si sunt de fapt niste date. Le puteti pune p
    733 bytes (114 words) - 15:19, 6 February 2021
  • Benchmarks Game/Parallel/BinaryTrees
    io s n t = printf "%s of depth %d\t check: %d\n" s n t io "stretch tree" stretchN c
    6 KB (1,055 words) - 23:27, 18 April 2020
  • Performance/Strings
    import System.IO... import IO...
    3 KB (397 words) - 22:15, 18 April 2021
  • Safe Haskell
    * about ensuring that <code>IO</code>-based code which is inferred safe cannot perform arbitrary I/O. ...Safe Haskell infers that untrusted code inferred safe and ''not'' in <code>IO</code> can be run without fear (aside from fear of resource over-utilizatio
    3 KB (471 words) - 03:00, 5 August 2021
  • Web/Libraries/Formlets
    type MyForm a = XHtmlForm IO a handleDate :: ServerPartT IO Response
    8 KB (985 words) - 06:56, 16 September 2013
  • Monad (sans metaphors)
    ...merely produces that original argument. <code>(>>=)</code> arranges <code>IO</code> monadic structures sequentially, starting with the leftmost innermos
    4 KB (668 words) - 08:53, 21 September 2021
  • CPlusPlus from Haskell
    ...nC1Ebb" kapplication_KApplication :: (Ptr KApplication) -> CInt -> CInt -> IO () qwidgets :: (Show a, QWidgetList a) => a -> IO ()
    15 KB (2,199 words) - 00:32, 23 May 2017
  • What a Monad is not
    ...well, apart from the current Haskell standard defining the way IO is done in terms of Monads: [http://donsbot.wordpress.com/2009/01/31/revivi ...s the IO monad impure. But that's not a general property of monads - just IO. And even then, we can pretend that Haskell is a purely functional descript
    6 KB (1,032 words) - 16:45, 2 December 2020
  • Action
    * <code>IO a</code>, the type of I/O actions; .../O from an arbitrary function, unless that function is itself in the <code>IO</code> monad and called at some point, directly or indirectly, from <code>M
    3 KB (428 words) - 04:08, 12 April 2024
  • Bogre-Banana
    main :: IO () ...e setup the Behaviors and Events we need for the game. We can also do some IO in this monad. For that we simply use the <hask>liftIO</hask> function. So
    12 KB (1,907 words) - 21:33, 19 September 2015
  • UrlDisp
    instance MonadCGI (ReaderT Connection (CGIT IO)) where main :: IO ()
    4 KB (592 words) - 21:17, 29 June 2021
  • Safely running untrusted Haskell code
    ...r possibly make your own monadic type that is a restricted subset of <code>IO</code>). But it's a lot more complicated than that... The evaluator is essentially a function, <hask>eval :: String -> IO String</hask>, which takes a random Haskell string, verifies it, compiles i
    5 KB (830 words) - 12:41, 22 June 2021
  • Failure
    * Exception usually refers to an exception which is thrown in the IO monad. It can also refer to the actual typeclass "Exception" which was intr * IO exceptions. But they force your code into your IO monad, plus it's non-obvious that a function might fail with an exception b
    6 KB (961 words) - 12:45, 12 August 2019
  • Applicative functor
    Consider an extended IO monad which handles automated closing of allocated resources. liftToCleanup :: IO a -> CleanIO a
    8 KB (1,326 words) - 08:20, 31 March 2022
  • Contstuff
    testComp1 :: ContT () IO () txt <- io getLine
    12 KB (2,067 words) - 05:43, 9 March 2021
  • Humor
    ...eading the real world [https://nssdc.gsfc.nasa.gov/image/planetary/jupiter/io.jpg is tricky]. <!-- new image from https://photojournal.jpl.nasa.gov/catal *[[Humor/Erlkönig|King IO (freely adapted from Goethe)]]
    5 KB (667 words) - 22:52, 1 May 2024
  • Parallel/Glossary
    ...is a thread of execution for IO code. Multiple Haskell threads can execute IO code concurrently and they can communicate using shared mutable variables a ...a spark is evaluated in parallel with other computations, or other Haskell IO threads, depends on what your hardware supports and on how your program is
    4 KB (606 words) - 16:32, 17 April 2014
  • Namespaced IO Layer
    ...based on the ideas found in Plan 9 and Inferno, that is, to represent each IO capable resource as a virtual file server exposing a tree of files and dire Source code: http://code.google.com/p/hs-ogl-misc/source/browse/ under the io-layer directory.
    11 KB (1,853 words) - 02:34, 26 April 2021
  • Introduction to QuickCheck2
    -- that function to take it out of the IO monad? without moving entirely into a "black box" IO-based testing model.
    8 KB (1,214 words) - 00:46, 23 October 2017
  • 99 questions/Solutions/48
    tablen :: Int -> ([Bool] -> Bool) -> IO ()
    899 bytes (132 words) - 19:51, 18 January 2014
  • Implement a chat server
    main :: IO () mainLoop :: Socket -> IO ()
    11 KB (1,739 words) - 04:19, 19 April 2024
  • Monads as containers
    all have to do with IO?". Well, in Haskell, IO is a monad. How does this mesh with the notion of a
    18 KB (3,270 words) - 05:36, 9 March 2021
  • CouchDB
    storeNewNote :: DB -> Note -> IO () changeNoteContent :: DB -> Doc -> Note -> IO ()
    12 KB (1,556 words) - 15:19, 6 February 2021
  • DDC/EffectSystem
    Instead of state monads (like <hask>IO</hask>), Disciple uses default strict evaluation and effect typing to deal In Haskell, because <hask>putStr</hask> prints to the screen it has the <hask>IO</hask> constructor in its return type:
    5 KB (834 words) - 04:20, 8 June 2023
  • Avoiding IO
    It may be possible to use a simpler, more specific type than <code>IO</code> for certain tasks. randomDist :: (Random a, Num a) => (a -> a) -> IO a
    10 KB (1,634 words) - 22:52, 6 April 2022
  • Evaluation order and state tokens
    <pre class="haskell">import System.IO.Unsafe <pre class="haskell">import System.IO.Unsafe
    21 KB (3,408 words) - 09:26, 9 September 2014
  • Lightweight concurrency
    unsafeIOToPTM :: IO a -> PTM a atomically :: PTM a -> IO a
    19 KB (2,840 words) - 16:41, 1 August 2021
  • Control-event
    The control-event package provides the capability to schedule and cancel IO () actions for arbitrary absolute times. Source code is available from hac
    1 KB (192 words) - 10:06, 20 April 2021
  • Multi-parameter type class
    instance VarMonad IO IORef where ...
    1 KB (198 words) - 22:52, 21 July 2021
  • New monads/MonadAdvSTM
    onCommit :: IO a -> STM () The idea is that onCommit would queue up an IO action to be performed when the transaction commits, but without any atomic
    24 KB (3,463 words) - 05:20, 12 July 2021
  • Gtk2Hs/Tutorials/Intro
    ...reasonably familiar with Haskell and in particular, writing code using the IO [[Monad]]. ...me <hask>ReaderT r IO</hask> monad but <hask>mainQuit</hask> is just <hask>IO</hask>.
    9 KB (1,531 words) - 08:59, 23 May 2021
  • Introduction to QuickCheck1
    -- that function to take it out of the IO monad? without moving entirely into a "black box" IO-based testing model.
    8 KB (1,186 words) - 20:49, 28 May 2021
  • High-level option handling with GetOpt
    import System.IO , optInput :: IO String
    8 KB (1,082 words) - 23:30, 3 December 2020
  • Tangible Value
    TVs, outputs, and inputs are not restricted to GUIs and IO. In general, they are parameterized by the mechanics of "transmitting valu ...two different mechanisms, namely [[Phooey]]'s <hask>UI</hask> AF and <hask>IO</hask>. The sinks are counterparts <hask>IU</hask> and <hask>OI</hask>.
    13 KB (1,988 words) - 02:05, 24 September 2021
  • New monads/MonadRandom
    evalRandIO :: Rand StdGen a -> IO a You may also want a MonadRandom instance for IO:
    6 KB (894 words) - 13:41, 2 April 2019
  • Monads as containers/is
    3 KB (553 words) - 12:08, 13 August 2015
  • Gtk2Hs/Tutorials/ThreadedGUIs
    <haskell>>main :: IO () ...'s own thread however. So we'll have to send GTK a drawing action(of type IO a). We can use one of two functions to do this. postGUIAsync, which simpl
    4 KB (613 words) - 21:06, 7 October 2014
  • Gallery
    ...ss a random number]]: Simple 'guess the random number game', demonstrating IO, random numbers, and basic environment interaction (getArgs, exitWith, user
    1 KB (203 words) - 15:17, 6 February 2021
  • ListT done right
    myTest :: Int -> ListT IO (Int, Int) runMyTest :: Int -> IO (Int, Int)
    13 KB (2,036 words) - 13:54, 4 July 2023
  • Cookbook/Dates And Time
    getCPUTimeDouble :: IO Double
    2 KB (224 words) - 21:06, 6 January 2019
  • FFI cook book
    :: Ptr a -> IO (Ptr a) > OCIHandle -> Ptr OCIHandle -> CInt -> CInt -> Ptr a -> IO CInt
    16 KB (2,449 words) - 17:06, 17 April 2017
  • Web/Framework Interfaces
    ...face, allowing constant-space response construction without needing [[Lazy IO|lazy I/O]]. Backends available are currently a simple server, CGI, FastCGI,
    2 KB (217 words) - 12:02, 19 April 2024
  • HaskellImplementorsWorkshop/2013/Berthold
    ...n be serialised in their current evaluation state, including functions and IO actions. This opens the way to interesting applications such as memoisation
    1 KB (204 words) - 06:38, 16 September 2013
  • Metaチュートリアル
    ...PaperStore/db-utwente-0000003696.pdf The Haskell Programmer's Guide to the IO Monad] # 特にIOの使い方を知りたい方
    5 KB (398 words) - 11:37, 22 October 2022
  • Yampa/game engine
    ...o the game objects correspondignly. The input comes from non-deterministic IO sources (time, gamepad, harddisk etc.).
    2 KB (278 words) - 10:21, 16 September 2015
  • Real World Applications/Event Driven Applications
    ...so that it can scale from small "toy" applications (dealing with low level IO events) to large scale, high volume, distributed, fault tolerant "Enterpris uiUpdate :: Domain -> IO [Event]
    7 KB (1,076 words) - 08:53, 4 July 2014
  • Continuation
    print (mysqrt 4) :: IO () mysqrtCPS 4 print :: IO ()
    10 KB (1,560 words) - 12:02, 15 April 2024
  • Open research problems
    ...T.runST</code> without using the built-in monadic <code>ST</code> or <code>IO</code> types. This needs to happen with operations that all run in ''O''(1)
    1 KB (200 words) - 12:50, 31 May 2022
  • The Monad.Reader/Issue2/Bzlib2Binding
    readBzip2 :: Handle -> IO String writeBzip2 :: Handle -> String -> IO ()
    15 KB (2,511 words) - 06:03, 1 June 2022
  • Tutorials/Programming Haskell/Introduction
    Which is the same as failing with an IO error. We can specify this specifically with a type annotation, to say "fail with an IO error":
    13 KB (1,817 words) - 17:53, 20 October 2016
  • Roll your own IRC bot
    import System.IO -- base main :: IO ()
    21 KB (3,285 words) - 19:34, 11 April 2024
  • Haskell for multicores
    forkIO :: IO () -> IO ThreadId newMVar :: a -> IO (MVar a)
    12 KB (1,738 words) - 06:06, 23 July 2020
  • Parallel
    # Manage simultaneous IO actions (eg. multiple connections on a web server)
    2 KB (278 words) - 15:17, 6 September 2013
  • GHC/As a library (up to 6.8)
    defaultErrorHandler :: DynFlags -> IO a -> IO a -> IO Session -- your session; you will need it
    18 KB (2,724 words) - 11:05, 17 January 2014
  • Plainly partible
    * Nobuo Yamashita uses a type reminiscent of ''pseudodata'' in his <code>IO</code>-alternative [https://hackage.haskell.org/package/oi ''oi''] package: import GHC.Base(IO(..), FauxWorld)
    11 KB (1,656 words) - 22:33, 4 July 2022
  • Error
    The possibility to catch such errors in the <hask>IO</hask> monad is really tempting for abuse.
    2 KB (296 words) - 15:56, 7 August 2022
  • Do notation considered harmful
    ...kly believe that the <hask>do</hask> notation is necessary for doing <hask>IO</hask>, * Newcomers might think that <hask>IO</hask> is somehow special and non-functional, in contrast to the advertisem
    10 KB (1,589 words) - 01:08, 27 September 2021
  • Internationalization of Haskell programs using gettext
    import IO import IO
    10 KB (1,489 words) - 15:02, 26 October 2016
  • Xmonad/Guided tour of the xmonad source/Core.hs
    newtype X a = X (ReaderT XConf (StateT XState IO) a) ...lt is IO; this is necessary since communicating with the X server involves IO operations. On top of that is <hask>StateT XState</hask>, which automatica
    13 KB (2,057 words) - 10:15, 28 September 2017
  • Sandbox
    import System.IO.UTF8 main :: IO ()
    5 KB (503 words) - 07:14, 22 December 2021
  • Tutorials/Programming Haskell/String IO
    main :: IO () ...tp://haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html System.IO] library.
    19 KB (3,139 words) - 04:08, 22 October 2021
  • WxHaskell/Quick start
    main :: IO () hello :: IO ()
    14 KB (2,248 words) - 15:18, 6 February 2021
  • ListT done right alternative
    -- The first one is more like the IO monad works, the second one catches
    2 KB (402 words) - 06:31, 12 May 2015
  • Haste
    widget. It was based on using IO much, and we discussed it and were
    2 KB (310 words) - 05:54, 10 October 2013
  • 10分で学ぶHaskell
    <hask>main</hask>と呼ばれる[[Introduction to Haskell IO/Actions |IO action]]の定義について先に触れました。
    17 KB (1,020 words) - 07:22, 9 June 2023
  • OCaml
    ...f immutable data, it also has mutable references and arrays available, and IO is performed by ordinary functions.
    2 KB (293 words) - 16:34, 15 May 2023
  • Rhine
    We can also use other monads, like <hask>IO</hask>: printHeight :: ClSF IO cl a ()
    8 KB (1,207 words) - 21:07, 26 September 2018
  • FFI complete examples
    foreign import ccall "time" c_time :: Ptr a -> IO CTime getTime :: IO CTime
    7 KB (1,181 words) - 21:12, 30 August 2014
  • Enumerator and iteratee
    ...ile or a socket (a stream) where a list of characters is read from. [[Lazy IO|Lazy I/O]], which uses lazy lists, closes a stream only when the stream is enumerator :: FilePath -> Iteratee (Maybe Char) o -> IO o
    6 KB (927 words) - 12:02, 19 April 2024
  • GPipe/Tutorial
    > main :: IO () > renderFrame :: Texture2D RGBFormat -> IORef Float -> Vec2 Int -> IO (FrameBuffer RGBFormat () ())
    11 KB (1,451 words) - 08:50, 19 April 2014
  • Cookbook/Files
    The System.IO library contains the functions needed for file IO. The program import System.IO
    2 KB (345 words) - 21:08, 6 January 2019
  • Package versioning policy
    instance MonadLogger IO main :: IO ()
    9 KB (1,408 words) - 20:31, 2 October 2016
  • Dealing with binary data
    ==== Simple file IO ==== main :: IO ()
    17 KB (2,795 words) - 04:06, 16 June 2020
  • Top level mutable state
    ...rary with explicit state parameterization and a function <hask>Lib.init :: IO Lib.State</hask>. type MyIO a = (?ref :: IORef Int) => IO a
    29 KB (4,624 words) - 05:37, 1 January 2022
  • Xmonad/Config archive/nomeata’s xmonad.hs
    import System.IO , ((modMask .|. shiftMask, xK_q ), io (exitWith ExitSuccess))
    7 KB (748 words) - 15:19, 6 February 2021
  • Parallel/Reading
    ...”, Peyton Jones, 2001. Classic introduction to concurrency in Haskell (and IO), and how to use MVars and Channels.
    3 KB (408 words) - 08:06, 12 June 2023
  • Shootout/Fannkuch
    perm <- mallocArray n :: IO (Ptr Int) (Ptr c#) <- mallocArray n :: IO (Ptr Int)
    22 KB (3,539 words) - 00:49, 14 December 2016
  • HUnit 1.0 User's Guide
    type Assertion = IO () ...mputation that always produces a void result. Why is an assertion an <code>IO</code> computation? So that programs with real-world side effects can be te
    23 KB (3,542 words) - 03:11, 15 May 2020
  • ALUT
    ...eVar}}: This package contains state variables, which are references in the IO monad, like IORefs or parts of the OpenGL state
    3 KB (433 words) - 10:44, 15 October 2015
  • Existential type
    #If you're in IO and have an expression that might throw an exception, <hask>catch</hask> le draw :: a -> IO ()
    13 KB (2,093 words) - 10:57, 25 October 2023
  • Simple Unix tools
    io f = interact (unlines . f . lines) [("blank", io blank )
    6 KB (842 words) - 05:27, 8 February 2016
  • Heterogenous collections
    main :: IO () main :: IO ()
    5 KB (863 words) - 11:44, 22 August 2021
  • Es/Librerias y Herramientas/Estructuras de Datos
    === IO === * Unboxed references in IO and ST monads
    10 KB (1,459 words) - 19:29, 15 August 2019
  • Mutable variable
    instance C IO where
    2 KB (338 words) - 20:04, 13 May 2020
  • Monad
    * I/O using <code>IO</code> monad ...sing <code>do</code>-notation and a monad like <code>State</code> or <code>IO</code>, programs in Haskell look very much like programs written in an impe
    13 KB (1,870 words) - 11:14, 22 October 2022
  • Learning Haskell
    * [https://learnyouahaskell.github.io/ Learn You a Haskell for Great Good! - Community version] An up-to-date com *[https://stevekrouse.github.io/hs.js/ Pattern matching, first-class functions, and abstracting over recurs
    9 KB (1,327 words) - 14:24, 18 March 2024
  • Functional dependencies vs. type families
    convert :: (MakeValueTuple a b) => StablePtr a -> IO (Ptr b) convert :: StablePtr a -> IO (Ptr (ValueTuple b))
    6 KB (936 words) - 20:35, 27 January 2014
  • WebApplicationInterface
    import System.IO (hFlush, hPutStr, stderr, stdin, stdout) serveWithCgi :: Application -> IO ()
    14 KB (2,193 words) - 05:45, 12 July 2021
  • Example code
    monadic IO, and sometimes other advanced features such as concurrency:
    6 KB (921 words) - 11:17, 22 October 2022
  • OpenAL
    ...eVar}}: This package contains state variables, which are references in the IO monad, like IORefs or parts of the OpenGL state
    4 KB (576 words) - 15:47, 13 October 2015
  • OpenGLTutorial2
    main :: IO () cube :: GLfloat -> IO ()
    20 KB (3,092 words) - 11:52, 20 September 2013
  • Xmonad/Guided tour of the xmonad source
    ...tional heart of xmonad. Far removed from corrupting pollutants such as the IO monad and the X server, it is a beautiful, limpid pool of pure code which d
    3 KB (531 words) - 09:09, 15 August 2017
  • Shootout/SumFile
    This entry was ruled illegal. Doesn't use line oriented IO. import System.IO.Error as Err
    20 KB (3,239 words) - 02:07, 26 April 2021
  • Physical units
    ...a runtime error. This design allows the programmer to process values from IO world with units, that are unknown at compile time, but it prohibits catchi
    3 KB (521 words) - 07:04, 13 September 2016
  • X window programming in Haskell
    main :: IO () -> IO Window
    61 KB (8,858 words) - 11:47, 5 November 2020
  • BerkeleyDBXML
    inTransaction :: XmlManager -> (XmlTransaction -> IO a) -> IO a ...ctional code runs in a monad of its own that prevents normal access to the IO monad.
    15 KB (2,390 words) - 15:19, 6 February 2021
  • Ru/IO
    ...это обычная функция, тип результата которой обёрнут в конструктор типов '''IO'''. putChar :: Char -> IO () -- выводит один символ на stdout
    25 KB (918 words) - 06:01, 1 June 2022
  • Tutorials/Programming Haskell/Argument handling
    getArgs :: IO [String] getProgName :: IO String
    25 KB (3,657 words) - 18:20, 12 September 2015
  • From a newbie II
    I think I'm getting it...amazing. Start by understanding IO. Then realize what a monad IS. Then make your own monads. Oh my gosh.
    2 KB (390 words) - 15:19, 6 February 2021
  • OpenGLTutorial1
    main :: IO () main :: IO ()
    10 KB (1,585 words) - 09:22, 20 September 2013
  • GHC/Using the FFI
    foreign import foo :: Int -> IO Int foreign import "foo_wrap" foo :: Int -> IO Int
    29 KB (4,766 words) - 05:52, 1 June 2022
  • Haskell IO for Imperative Programmers
    main :: IO () processIt :: String -> IO ()
    20 KB (3,555 words) - 06:05, 24 April 2024
  • Kernel Modules
    foreign import regparm3 unsafe foo :: CString -> IO CInt foreign export regparm3 hello :: IO CInt
    8 KB (1,231 words) - 18:14, 20 February 2017
  • GObjectIntrospection
    -> IO [Child]
    4 KB (553 words) - 17:16, 15 January 2017
  • Denotative programming timeline
    ...reofcoding.org/log.html#my-growing-anti-io-monad-obsession My growing Anti-IO-Monad Obsession] - Steve Krouse
    4 KB (506 words) - 06:17, 20 April 2024
  • New monads/MonadExit
    instance MonadExit Sys.ExitCode IO where
    4 KB (707 words) - 09:43, 9 December 2014
  • Learn Haskell in 10 minutes
    [[Introduction to IO |I/O actions]] can be used to read from and write to the console. Some com We wrote a definition of an [[Introduction to Haskell IO/Actions |IO action]] earlier, called <hask>main</hask>:
    13 KB (1,986 words) - 17:59, 9 August 2019
  • ZuriHac2016/Attendees
    | Vincent Hanquez || Typed IO
    4 KB (495 words) - 17:39, 20 July 2016
  • Cookbook/Other data structures
    ...y.IO.IOArray i e</hask> are updated in place, but they have to live in the IO-monad or the ST-monad in order to not destroy referential transparency. The
    4 KB (640 words) - 21:05, 6 January 2019
  • Xmonad/Config archive/yiannist's xmonad.hs
    main :: IO ()
    6 KB (566 words) - 20:23, 21 June 2015
  • 99 questions/61 to 69
    io = treeToInorder t } in preInTree po io >>= print
    12 KB (1,696 words) - 05:35, 11 June 2023
  • Arrays
    ! IO monad<br><hask>instance MArray a e IO</hask> ...ell.org/ghc/docs/latest/html/libraries/array/Data-Array-IO.html Data.Array.IO]) ==
    27 KB (4,333 words) - 06:09, 23 July 2020
  • WikipediaArticleDesign
    * Monadic IO
    3 KB (332 words) - 03:38, 14 August 2021
  • Cxx foreign function interface
    * [[IO inside]] describes how to interface to a C++ library using the "export C" d
    4 KB (618 words) - 22:55, 11 July 2021
  • Learning Haskell with Chess
    *special character <hask>'\n'</hask>, <hask>putStr::String->IO ()</hask>
    4 KB (546 words) - 02:12, 26 April 2021
  • FRP explanation using reactive-banana
    ...tant to note that any kind of value may be put into value boxes, including IO actions and functions. import System.IO (BufferMode(..), hSetEcho, hSetBuffering, stdin)
    25 KB (4,168 words) - 15:10, 24 October 2017
  • MonadFix
    ...rithm, which brings in the IO Monad or the Writer Monad (this example uses IO); and to feed a return value back into a parameter in this monadic algorith
    10 KB (1,757 words) - 23:34, 24 July 2021
  • Foreign Function Interface
    * the return type is either a ''marshallable foreign type'' or has the form IO t where t is a marshallable foreign type or (). ...rforms side-effects, you have to explicitly indicate it in its type (using IO). GHC has no other way to detect it.
    33 KB (5,008 words) - 16:46, 20 December 2023
  • FAQ
    ...longside static types, algebraic data, laziness, type classes, first-class IO, etc. For an introduction to FP by itself you might want to learn Scheme, o No; [[Introduction to IO|I/O in Haskell]] is straightforward.
    36 KB (5,813 words) - 06:04, 13 April 2024
  • CabalFind
    -> IO [(URI,String)] -- returned list of (URI, label) pairs
    4 KB (666 words) - 22:21, 23 April 2021
  • Aprende Haskell en 10 minutos
    Las [[Introduction to IO|Acciones I/O]] se pueden usar para leer y escribir en Habíamos escrito la definición de [[Introduction to Haskell IO/Actions|acciones
    14 KB (2,164 words) - 16:35, 9 October 2016
  • Xmonad/Config archive/Gwern's xmonad.hs
    main :: IO ()
    6 KB (615 words) - 23:47, 28 November 2018
  • Literate programming
    main :: IO () main :: IO ()
    10 KB (1,524 words) - 22:20, 13 November 2022
  • Monomorphism restriction
    ...Haskell defaulting, the type of <hask>p</hask> silently became <hask>() -> IO ()</hask>. No surprise that my new "short" version of print was only capabl -- xmlGetWidget' :: WidgetClass widget => (GObject -> widget) -> String -> IO widget
    16 KB (2,628 words) - 21:19, 16 December 2022
  • WxHaskell/Development
    ...a new model for programming GUI interfaces: everything is still in the <tt>IO</tt> monad and state is handled through mutable variables.
    6 KB (743 words) - 16:02, 26 April 2017
  • GLFW
    ...ike structure for this purpose. The <hask>Action</hask> type represents an IO operation that returns the next <hask>Action</hask> to continue execution. data Action = Action (IO Action)
    10 KB (1,537 words) - 21:44, 2 October 2014
  • HaskellImplementorsWorkshop/2016
    ...s often find themselves "trapped in a monad". Given a computation of type 'IO a', there is no way to get the 'a' value "out" of the computation. One can ...hen evaluated, 'box N' suspends its evaluation, returning a value of type 'IO a'. This idea has been described previously, by both Filinski [1] who named
    16 KB (2,520 words) - 06:08, 16 October 2016
  • Ru/IO Inside
    ...реализации Haskell I/O и постепенно сделать из вас специалиста по работе с IO. Более того, я добавил детальное описание
    64 KB (6,046 words) - 11:23, 22 October 2022
  • New monads
    Here is an extension of STM to easy interaction with IO after committing or retrying. Inspired by Simon P-J.
    4 KB (648 words) - 09:43, 9 December 2014
  • HStringTemplate
    templates <- directoryGroup "/path/to/your/templates/" :: IO (STGroup ByteString) If you have IO errors or the template does not exist, you will get an exception — error
    12 KB (1,726 words) - 15:16, 6 February 2021
  • Numeric Haskell: A Repa Tutorial
    * [http://hackage.haskell.org/package/repa-io repa-io] Using the [http://hackage.haskell.org/package/repa-io repa-io] package, arrays may be written and read from files in a number of formats:
    37 KB (5,672 words) - 07:28, 10 August 2022
  • Euler problems/181 to 190
    randomStart :: Int -> IO [Char] main :: IO ()
    15 KB (2,018 words) - 01:29, 26 April 2021
  • Phantom type
    useData :: FormData Validated -> IO ()
    5 KB (868 words) - 06:40, 11 June 2021
  • Monad/ST
    The ST type lets you use update-in-place, but is escapable (unlike <code>IO</code>).
    5 KB (802 words) - 05:38, 4 August 2021
  • Tutorials
    ...opics include basic list manipulations, higher order functions, cabal, the IO Monad, and Category Theory. ;[http://learn.hfm.io/ Learning Haskell]
    31 KB (4,662 words) - 08:38, 20 April 2024
  • Applications and libraries/Network
    :Alternative high speed network implementation supporting various IO strategies including epoll.
    6 KB (929 words) - 18:17, 31 August 2016
  • Yhc/Javascript/Programmers guide/Echo demo source
    -- Similarly, return a value wrapped into the IO monad. The `a' argument -- But since there is no "traditional" input/output in a web browser, the IO monad
    12 KB (2,023 words) - 22:51, 5 April 2021
  • GHC/GHCi
    dotGHCI_myPrint :: (Show a) => a -> IO () :def! nopretty \_ -> return ":set -interactive-print System.IO.print"
    21 KB (3,021 words) - 12:03, 15 May 2020
  • Haskell programming tips
    linify :: [String] -> IO () ===Separate IO and data processing===
    29 KB (4,702 words) - 12:36, 4 May 2021
  • AtomicMemoryOps
    casIORef :: IORef a -> Ticket a -> a -> IO (Bool, Ticket a)
    5 KB (865 words) - 18:26, 21 November 2013
  • HXT/Conversion of Haskell data from/to XML
    main :: IO () storeProgram :: IO ()
    28 KB (3,540 words) - 18:19, 5 January 2015
  • ItaloHaskell/Summer 2008
    ...cesso al wiki, mandatemi un email a tittoassini@gmail.com e vi aggiungero' io alla lista):
    4 KB (544 words) - 00:59, 12 July 2021
  • Parsing expressions and statements
    > play :: String -> IO ()
    8 KB (1,033 words) - 02:43, 21 March 2018
  • OOP vs type classes
    proc :: (IO (), IO Int) -> IO () [[IO inside#Example: returning an IO action as a result]]
    30 KB (4,685 words) - 01:34, 14 July 2021
  • Intrebarile incepatorului
    * [[De ce sunt mai bune actiunile de IO decat instructiunile de I/O ?]] * [[Unde mai pot citi ceva despre IO ?]] <br>
    14 KB (1,971 words) - 23:12, 9 April 2021
  • A brief introduction to Haskell
    Commands have types of the form <hask>IO a</hask>, which says it takes <hask>b -> IO a</hask>, and I will abuse terminology and call this a
    41 KB (6,592 words) - 22:27, 3 May 2024
  • HXT
    ...We e.g. want to do some I/O while staying at the filter level, so for the IO monad we need something like:<p></p> type XmlIOFilter = XmlTree -> IO [XmlTree]
    48 KB (6,937 words) - 00:20, 27 April 2016
  • IO inside
    ...Haskellers - if that's you, a good place to start is the [[Introduction to IO]] which can help you learn the basics (e.g. the syntax of I/O expressions) data IO a = Act (Time -> (a, Time))
    82 KB (13,140 words) - 09:07, 3 May 2024
  • The Monad.Reader/Issue2/FunWithLinearImplicitParameters
    unsafePerformIO :: IO a -> a The <hask>unsafePerformIO</hask> function executes an <hask>IO</hask> action and returns the result as a pure value. Thus, it should only
    35 KB (5,673 words) - 20:05, 7 July 2015
  • Rubiks Cube
    main :: IO ()
    8 KB (1,020 words) - 01:02, 23 September 2018
  • SDL
    ...y functional widgets and a mainloop adapter to adapt the widgets to run in IO
    7 KB (1,003 words) - 23:19, 5 April 2021
  • Applications and libraries
    and [http://www.haskell.org/onlinereport/haskell2010/haskellch41.html System.IO]. Within GHC, these are mostly grouped into the [http://hackage.haskell.org * [[/Data structures | Data Structures and IO Libraries]]
    8 KB (1,114 words) - 01:40, 1 March 2020
  • How to write a Haskell program
    ...ting, particularly with impure code, can be done with [http://hspec.github.io/ HSpec] and [http://hackage.haskell.org/package/HUnit HUnit]. ...braries that are provided by the current stable [http://daniel-diaz.github.io/stackagelist/ Stackage package versions] or the [http://haskell.org/platfor
    22 KB (3,268 words) - 04:57, 30 January 2022
  • Library/Streams
    ...tee_I/O]] and in particular [http://hackage.haskell.org/package/io-streams io-streams] is similar in it's focus on I/O and replacing file handles. Stream class implementations both for IO and ST monads. Yes, you can
    21 KB (3,181 words) - 16:03, 14 March 2014
  • GHC/Data Parallel Haskell
    ...e parts of a program cannot be vectorised – for example, code in the <hask>IO</hask> monad (the radical re-ordering of computations performed by the vect main :: IO ()
    21 KB (3,158 words) - 08:39, 10 August 2022
  • Euler problems/71 to 80
    main :: IO ()
    7 KB (972 words) - 02:57, 3 May 2015
  • Output/Input
    * [[IO then abstraction]]
    8 KB (1,236 words) - 12:36, 1 January 2024
  • Applications and libraries/Concurrency and parallelism
    ...both Concurrent Haskell and GpH, enabling the distribution of the stateful IO threads of the former on the multiple locations of the latter. The programm
    7 KB (998 words) - 06:02, 12 June 2023
  • Applications and libraries/Interfacing other languages
    ...Interfacing_with_C.2FC.2B.2B_and_foreign_libraries_.28under_development.29 IO inside] guide.
    7 KB (1,100 words) - 06:49, 8 June 2023
  • Nitpicks
    type IO# a = (a -> IOCall#) -> IOCall#
    7 KB (1,033 words) - 01:16, 27 September 2021
  • AutoForms
    main :: IO ()
    7 KB (1,004 words) - 01:32, 9 April 2021
  • The I/O problem
    :<small>[https://maartenfokkinga.github.io/utwente/mmf2001c.pdf An alternative approach to I/O], Maarten Fokkinga and these operations over the <code>IO</code> monad, is that destructive updates to variables in
    61 KB (9,234 words) - 04:14, 5 April 2024
  • Tying the Knot
    ...wanted better messages you'd have to put most of the parsing in the <code>IO</code> monad so that you could catch the error earlier and provide more inf ...nd also allows you to recover from an error without resorting to the <code>IO</code> monad and/or extensions (Oleg's can't do this),
    24 KB (3,850 words) - 17:16, 28 June 2021
  • WxHaskell
    ...0.1.1.167.3926&rep=rep1&type=pdf Can GUI Programming Be Liberated From The IO Monad] * [http://uu-computerscience.github.io/js-asteroids/ wxHaskell for the web]: a port of a subset of wxHaskell to th
    9 KB (1,259 words) - 13:40, 5 May 2018
  • GHC/As a library
    main :: IO ()
    9 KB (1,261 words) - 15:40, 22 December 2017
  • Arrow tutorial
    > main :: IO ()
    8 KB (1,316 words) - 00:00, 17 June 2021
  • ZuriHac2016/Projects
    the current IO support in the Standard Library/Prelude and maybe fix a bug or
    8 KB (1,190 words) - 12:03, 24 July 2016
  • Applications and libraries/GUI libraries
    [https://lettier.github.io/webviewhs webviewhs] is a Haskell binding to the [https://github.com/zserge ...thub.com/lettier/webviewhs GitHub repository], the [https://lettier.github.io/webviewhs documentation] and [https://github.com/lettier/webviewhs/tree/mas
    16 KB (2,346 words) - 05:33, 8 June 2023
  • Hitchhikers guide to Haskell
    constructors", "monadic IO", at which point they usually panic, think == Chapter 1: Ubiquitous "Hello world!" and other ways to do IO in Haskell ==
    69 KB (11,026 words) - 12:26, 9 January 2023
  • The Monad.Reader/Issue4/Why Attribute Grammars Matter
    Everyone loves monads. They're what makes IO possible in Haskell. There are order to perform IO in a functional language; by constraining all IO
    22 KB (3,703 words) - 21:20, 30 May 2021
  • Parsing a simple imperative language
    > import System.IO > parseFile :: String -> IO Stmt
    11 KB (1,437 words) - 00:04, 1 September 2017
  • Error vs. Exception
    <hask>Maybe</hask>, <hask>Either</hask>, exceptions in <hask>IO</hask> monad, or return codes, ...e exceptional situation is signaled by a return code that you ignore or an IO exception for which you did not run a <hask>catch</hask>.
    16 KB (2,728 words) - 16:45, 23 July 2019
  • Haskellへのヒッチハイカーガイド
    ...、段落を読み飛ばして、章を読み飛ばして、結局ページまるごと読み飛ばしてしまったよ。で、ようやく50ページくらいで"型クラス"、"型コンストラクタ"、"IOモナド"といった概念の説明している個所だと気がついて == 第１章：ユビキタス "Hello world!" とHaskellでIOを行う方法 ==
    73 KB (10,050 words) - 00:05, 19 April 2021
  • HaTeX User's Guide
    renderFile :: Render a => FilePath -> a -> IO () type LaTeXIO = LaTeXT IO
    21 KB (3,518 words) - 09:52, 14 May 2014

View (previous 250 | next 250) (20 | 50 | 100 | 250 | 500)

Retrieved from "https://wiki.haskell.org/Special:Search"