- Haskell-Cafe - Haskell.org

International Conference on Recent Theories and Applications in Transportation and Mobility - (RTATM 2021) Prague
by matteo＠confscience.com 20 Apr '21

20 Apr '21

Call for papers ************************************************* International Conference on Recent Theories and Applications in Transportation and Mobility - (RTATM 2021) Prague - Czech Republic, October 14-15, 2021 https://confscience.com/rtatm/ All papers accepted in RTATM 2021 will be published in Springer CCIS (Communications in Computer and Information Science). CCIS is abstracted/indexed in Scopus, SCImago, EI-Compendex, Mathematical Reviews, DBLP, Google Scholar, and Thomson Reuters Conference Proceedings Citation (Former ISI Proceedings) *************************************************************************** IMPORTANT DATES: - Paper Submission: April 20, 2021 (extended) - Acceptance Notification: July 1, 2021 - Final Manuscript Due: September 1, 2021 *************************************************************************** The RTATM 2021 conference will be held in Conjunction with: International Conference on Applied Data Science and Intelligence (ADSI 2021) International Conference on Informatics Revolution for Smarter Healthcare (IRSH 2021) *************************************************************************** TOPICS: Authors are invited to submit their original papers to address the topics of the conference, including but not limited to: FUNDAMENTALS AND THEORIES - Modelling and Simulation Algorithms - Vehicular Wireless Medium Access Control - V2X communications - Routings and Protocols for Connected Vehicles - Mobility Models and Architectures - Distribution Strategies - Traffic Incident Management Systems - Bio-Inspired Approaches - Optimization and Collaboration - Automatic Control in Vehicular Networks - Energy-aware Connected Mobility - Programming Languages - Sustainable Transportation - Multimodal Transportation Networks and Systems - Systemsb Integration - Driver Behavior Models and Simulation - Human Factors and Travel Behaviour - Green Mobility - Regulations and Bylaws for Intelligent - Transportation and Mobility SMART TRANSPORTATION AND LOGISTICS - Mobility Management - Connected Vehicles - VANETs - Predictive Logistics - Spatio-Temporal Event Tracking - Decision Support Systems - Emergency Management - Logistics and E-Commerce - Supply Chain Design and Execution - Supply Chain Management - Advanced Planning Systems - Fleet Management - Multi-Agent Systems - Machine Learning for Smart Logistics - Intelligent Infrastructures - Real-time Analysis of Comprehensive Supply Chain Data - Smart Synchronization of Logistics Processes - New Approaches for Cost Transparency - Big Data for Smart Logistics - Logistics 4.0 - Mobile Networks - Next-Generation Smart Logistics - Performance Management Approaches - Tests and Deployment - Software Defined Networks - Smart Freight Management - Smart Shipment Management - Smart Warehousing - Smart Inventory management DATA AND SERVICES - Real-Time transportation Data Acquisition - Event Detection and Monitoring - Data Warehouses for connected mobility - Data mining and Data analytics - Data Worthiness in Connected Vehicles - Data Trustworthiness for effective transportation and mobility - Road Traffic Data Analytics - Structured and Unstructured Data for Connected Mobility - Volunteered Geographic Information (VGI) - Data Representation for Connected Mobility - Transportation Data Mining - Transportation and mobility Data Visualization - Cognitive and Context-aware Intelligence - Transportation Decision Support Systems - Mobility as a Service (MaaS) - Intelligent Transportation Services - Smart Mobility Services - Big Data and Vehicle Analytics - Massive Data Management - Collective and connected Intelligence - Next Generation Services - Driver Behaviour Analysis - Geo-Spatial Services - Service-Oriented Architecture (SOA) - Web and Mobile Services SAFETY, SECURITY, AND HAZARD MANAGEMENT - Security Issues in Vehicular Communications - Safety Applications of Connected Vehicles - Weather-related Safety solutions - V2V, V2I and I2V Road Safety Applications - Connected Mobility for Hazard Management - Risk Management - Road Traffic Crashes Analytics - Traffic Jam Prediction - Resource Allocation for Hazard Management - Trust and Privacy Issues in Logistics - Management of Exceptional Events - New approaches to Networking Security for Transportation Applications - Failure modes, human factors, software safety - Automated Failure Analysis - Performance and Human Error Analysis - Design and Reliability of Control Systems - Dispersion Modelling Software - Quantification of Risk *************************************************************************** OUTSTANDING PAPERS: Based on the peer review scores as well as the presentations at the conference, the authors of outstanding papers will be invited to extend their works for a potential publication in journals special issues with high impact factors. *************************************************************************** PAPER SUBMISSION: Papers must be submitted electronically as PDF files via easychair (https://easychair.org/conferences/?conf=rtatm2021) All papers will be peer reviewed. Length of Full papers: 12-15 pages long (written in the LNCS/CCIS one-column page format, 400 words per page) Length of Short papers: less than 12 pages For more information, please refer to the conference website: https://confscience.com/rtatm/ *************************************************************************** CONTACT For more information, please send an email to info-rtatm(a)confscience.com

1 0

Trick to have existential type work in this case?
by YueCompl 19 Apr '21

19 Apr '21

Dear Cafe, I believe there should exist some trick that I haven't learned, to have this compile: module PoC.Existential where import Data.Dynamic import qualified Data.Vector.Storable as VS import Foreign import Prelude -- * Necessary artifacts data Series a = Series { seriesLen :: IO Int, readSeries :: Int -> IO a } data SomeArray = forall a. (Typeable a, VS.Storable a) => SomeArray { arrayCap :: Int, arrayPtr :: ForeignPtr a } class ManagedArray t where arrayAtTheMoment :: t -> IO SomeArray data SomeManagedArray = forall t. (Typeable t, ManagedArray t) => SomeManagedArray t In following, I can confirm it works with the nested `do` block flattened (as shown later), but I really need it in the more complex real case, so please bear with me. -- * Things not working managedArrayAsSeries :: SomeManagedArray -> IO Dynamic managedArrayAsSeries (SomeManagedArray ma) = do vec <- do SomeArray cap fp <- arrayAtTheMoment ma return $ VS.unsafeFromForeignPtr0 fp cap let len = return $ VS.length vec rs i = return $ vec VS.! i return $ toDyn $ Series len rs The error: src/PoC/Existential.hs:36:5: error: • Couldn't match type ‘a’ with ‘a0’ ‘a’ is a rigid type variable bound by a pattern with constructor: SomeArray :: forall a. (Typeable a, Storable a) => Int -> ForeignPtr a -> SomeArray, in a pattern binding in a 'do' block at src/PoC/Existential.hs:35:5-20 Expected type: IO (VS.Vector a0) Actual type: IO (VS.Vector a) • In a stmt of a 'do' block: return $ VS.unsafeFromForeignPtr0 fp cap In a stmt of a 'do' block: vec <- do SomeArray cap fp <- arrayAtTheMoment ma return $ VS.unsafeFromForeignPtr0 fp cap In the expression: do vec <- do SomeArray cap fp <- arrayAtTheMoment ma return $ VS.unsafeFromForeignPtr0 fp cap let len = return $ VS.length vec rs i = return $ vec VS.! i return $ toDyn $ Series len rs • Relevant bindings include fp :: ForeignPtr a (bound at src/PoC/Existential.hs:35:19) | 36 | return $ VS.unsafeFromForeignPtr0 fp cap | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ While these more trivial things work as expected: -- * Things working managedArrayAsSeries' :: SomeManagedArray -> IO Dynamic managedArrayAsSeries' (SomeManagedArray ma) = do SomeArray cap fp <- arrayAtTheMoment ma let vec = VS.unsafeFromForeignPtr0 fp cap let len = return $ VS.length vec rs i = return $ vec VS.! i return $ toDyn $ Series len rs arrayAsSeries :: SomeArray -> Dynamic arrayAsSeries (SomeArray cap fp) = colAsSeries $ SomeColumn $ VS.unsafeFromForeignPtr0 fp cap arrayAsSeries' :: SomeArray -> Dynamic arrayAsSeries' (SomeArray cap fp) = do let vec = VS.unsafeFromForeignPtr0 fp cap len = return $ VS.length vec rs i = return $ vec VS.! i toDyn $ Series len rs data SomeColumn = forall a. (Typeable a, VS.Storable a) => SomeColumn (VS.Vector a) colAsSeries :: SomeColumn -> Dynamic colAsSeries (SomeColumn colVec) = toDyn $ Series len rs where len = return $ VS.length colVec rs i = return $ colVec VS.! i Please teach me the trick! Thanks with regards, Compl

2 2

How to move files?
by ☂Josh Chia (謝任中) 15 Apr '21

15 Apr '21

I'm trying to write to a temp file in /tmp and then move it to another location that may be in /tmp. If I use System.Directory.renameFile and the final location is in another filesystem, I'll get an error "renameFile:renamePath:rename: unsupported operation (Invalid cross-device link)". If I copy to the new location and then remove the temp file, but the new location is also in /tmp, I am doing an unnecessary copy (instead of mv), which is inefficient. I don't know how to detect whether two filepaths are in the same filesystem. What's the best way to move the file if possible but copy-and-delete if necessary? Josh

9 13

[ANN] wai-handler-hal-0.1.0.0 - Wrap a WAI Application to run on AWS Lambda
by Jack Kelly 15 Apr '21

15 Apr '21

I have just pushed an initial release of wai-handler-hal[1] to Hackage. This library lets you run `wai` `Application`s on AWS Lambda, using the proxy integration features of an API Gateway REST API. This allows you to write your APIs using tools like `servant`, test them locally using `warp`, and then build deployment binaries using `hal`. There's an especially nice payoff when you use `servant`: it's very easy to test the entire API locally using `warp`, but then split endpoints into individual Lambda binaries. This means you can assign minimal IAM policies to each Lambda when you deploy to AWS. The library code, an example API, example deployment code (in AWS CDK[2]), and extensive documentation are all available on GitHub[3]; bug reports and pull requests are welcome. Best, -- Jack [1]: https://hackage.haskell.org/package/wai-handler-hal-0.1.0.0 [2]: https://aws.amazon.com/cdk/ [3]: https://github.com/bellroy/wai-handler-hal

1 0

Re: [Haskell-cafe] Haskell function composition commutivity?
by Dominic Steinitz 14 Apr '21

14 Apr '21

I’d recommend *not* reading Categories for the Working Mathematician unless you are a mathematician (lots of background assumed) and even then it’s a bit of a dull read. Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.org Twitter: @idontgetoutmuch > From: Viktor Dukhovni <ietf-dane(a)dukhovni.org> > To: haskell-cafe(a)haskell.org > Subject: Re: [Haskell-cafe] Haskell function composition commutivity? > Message-ID: <YHYPMnJcYzdEolzl(a)straasha.imrryr.org> > Content-Type: text/plain; charset=us-ascii > > On Tue, Apr 13, 2021 at 02:19:46PM -0500, Galaxy Being wrote: > >> Your answers seem to originate outside of normal Haskell tutorials. Where >> can I start with this higher superset theory? > > There's a reason why the tutorials don't cover this, the categorical > foundations of Haskell types are not beginner material. It is perhaps > best to defer going down this rabbit hole until you're more comfortable > with the Haskell generally. > > You could start with: > > https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-… > https://bartoszmilewski.com/2015/04/07/natural-transformations/ > > For the Yoneda Lemma specifically, I'd recommend: > > http://blog.sigfpe.com/2006/11/yoneda-lemma.html > > Parametricity is covered in "Theorems for free": > > https://www2.cs.sfu.ca/CourseCentral/831/burton/Notes/July14/free.pdf > > but it is by no means elementary, though skimming it for the essential > facts and skipping the gory details is not too difficult. > > You could also read "Categories for the Working Mathematician" by > Saunders Mac Lane.

2 1

serialized data structures (Was: Generalized, named, and exportable default declarations)
by Olaf Klinke 14 Apr '21

14 Apr '21

> We have seen a lot of effort of better integrating Text into Haskell > programming. The only purpose of doing so is to replace String by > something more space and time efficient. What would happen if we invest > equally much time into making String as efficient as Text? At ICFP 2019 I > attended a talk about Gibbon: > > https://github.com/iu-parfunc/gibbon > > The idea of the project is to serialize (Haskell's) tree data structures > in memory as much as possible. Wouldn't this enable us to use String > instead of Text, again, maybe even lists instead of Vectors? No more Text > integration efforts, no more external library with GHC-specific manual > optimizations. Unfortunately, the project is still in an early stage. So > far, it only supports strict data structures. > > What if we would not complicate the language and generalize syntactic > sugar for Text, but instead improve data layout for all Haskell types and > eventually make a custom Text type unnecessary? So essentially Gibbon's aim is to make String work like Text under the hood, without me having to worry about it? +1 for that! Probably I should not comment on this, because I know too little about compilers and serialization. But having to expect something like OverloadedStrings for arbitrary type classes, plus which effect import statements have on this, puts extra cognitive load on the programmer. In contrast, the direction taken by Gibbon removes worries, namely: How much memory penalty do I pay by using this easy-to-understand algebraic data type instead of a more low-level compact representation? I love GHC specifically for its ability to perform many optimizations that Icould not have come up with. Indeed the GHC devs should strive to make the default [*] types work better, as this aligns with the mission of the Haskell Foundation to promote and widen adoption of Haskell. Olaf [*] "default" as dictated by the language report.

2 2

Generalized, named, and exportable default declarations (GHC Proposal)
by Eric Seidel 14 Apr '21

14 Apr '21

Hi Cafe, The GHC Steering Committee is considering a proposal that would expand the typeclass defaulting mechanism to support arbitrary (single-parameter) classes, and enable exporting defaulting rules. It's received very little input from the community so far, which is a shame because it's trying to address a common complaint about Haskell's String situation. Under the proposal Data.Text could export a rule defaulting IsString to Text. Client modules would automatically import defaulting rules just like class instances, which would make ambiguous string literals automatically default to Text. Please take a look at the proposal and leave your feedback, even if it's just "Yes, this would make my life meaningfully better" (reaction emoji are great for this level of feedback). Gauging the amount of pain caused by problems like this, and weighing that against the cost of new features, is one of the harder parts of being on the Committee. PR: https://github.com/ghc-proposals/ghc-proposals/pull/409 Rendered: https://github.com/blamario/ghc-proposals/blob/exportable-named-default/pro…

6 6

Haskell function composition commutivity?
by Galaxy Being 13 Apr '21

13 Apr '21

I'm in chapter 4 of Bird's very interesting *Thinking Functionally with Haskell *and he has a problem at the end of the chapter where he lists these equations map f . take n = take n . map f map f . reverse = reverse . map f map f . sort = sort . map f map f . filter p = map fst . filter snd . map (fork (f,p)) filter (p . g) = map (invertg) . filter p . map g reverse . concat = concat . reverse . map reverse filter p . concat = concat . map (filter p) adding this caveat for the 3rd equation iff x <= y <=> f x <= f y and this for the 4th equation fork (f,g) x = (f x, g x) and for the 5th invertg satisfies invertg . g = id My confusion is over the commutative-ness of most of this but only anecdotally. With the particularly dense map f . filter p = map fst . filter snd . map (fork (f,p)) We have > :t (map myF . filter myP) Integral b => [b] -> [b] > :t (map fst . filter snd . map (myFork (myF,myP))) Integral b => [b] -> [b] Is there anything universal to be drawn from these anecdotal examples of seeming commutativity? My breakdown of the third equation shows the same type definition for both sides. Is this a way to find equality? All in all, Bird doesn't indicate that there are any underlying truths, just "almost" commutativity. LB

3 6

Re: [Haskell-cafe] What's the modern way to apply a polymorphic function to a Dynamic value in GHC 8.8 and onwards?
by YueCompl 13 Apr '21

13 Apr '21

Thanks to Vlad and Jaro, your solution of `apD` compiles, I think it should work. But unfortunately my real case is a little different / more complex, a MWE appears like this: ```hs holdEvent :: Dynamic -> Dynamic holdEvent (Dynamic t evs') = withTypeable t $ Dynamic typeRep (hcHoldEvent evs') where hcHoldEvent :: forall a. EventSink a -> IO (TimeSeries a) hcHoldEvent !evs = do !holder <- newIORef Nothing listenEvents evs $ writeIORef holder . Just return $ TimeSeries $ readIORef holder data EventSink a = EventSink { listenEvents :: (a -> IO ()) -> IO (), closeStream :: IO () } instance Functor EventSink where fmap = undefined newtype TimeSeries a = TimeSeries {readTimeSeries :: IO (Maybe a)} instance Functor TimeSeries where fmap = undefined ``` Now I'm clueless how to use the `withTypeable` trick to apply my polymorphic `hcHoldEvent` to `Dynamic`, naively written as in above, the error is: ```log src/PoC/DynPoly.hs:20:49: error: • Couldn't match expected type ‘EventSink a0’ with actual type ‘a’ ‘a’ is a rigid type variable bound by a pattern with constructor: Dynamic :: forall a. base-4.13.0.0:Data.Typeable.Internal.TypeRep a -> a -> Dynamic, in an equation for ‘holdEvent’ at src/PoC/DynPoly.hs:19:12-25 • In the first argument of ‘hcHoldEvent’, namely ‘evs'’ In the second argument of ‘Dynamic’, namely ‘(hcHoldEvent evs')’ In the second argument of ‘($)’, namely ‘Dynamic typeRep (hcHoldEvent evs')’ • Relevant bindings include evs' :: a (bound at src/PoC/DynPoly.hs:19:22) t :: base-4.13.0.0:Data.Typeable.Internal.TypeRep a (bound at src/PoC/DynPoly.hs:19:20) | 20 | withTypeable t $ Dynamic typeRep (hcHoldEvent evs') | ^^^^ ``` Thanks with best regards, Compl > On 2021-04-12, at 22:04, Jaro Reinders <jaro.reinders(a)gmail.com> wrote: > > I have no experience in this area, but this compiles: > > ``` > {-# LANGUAGE RankNTypes, ScopedTypeVariables #-} > import Type.Reflection > import Data.Dynamic > > appD :: forall f. Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic > appD f (Dynamic rep (x :: a)) = withTypeable rep (toDyn (f x)) > ``` > > Cheers, > > Jaro > On 2021-04-12, at 21:06, Vladislav Zavialov <vladislav(a)serokell.io> wrote: > > Would something like this work for you? > > import Type.Reflection > import Data.Dynamic > > apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic > apD f (Dynamic t a) = withTypeable t $ Dynamic typeRep (f a) > > - Vlad > >> On 12 Apr 2021, at 14:34, YueCompl via ghc-devs <ghc-devs(a)haskell.org> wrote: >> >> Dear Cafe and GHC devs, >> >> >> There used to be a "principled way with pattern match on the constructor": >> >> ```hs >> data Dynamic where >> Dynamic :: Typeable a => a -> Dynamic >> >> apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic >> apD f (Dynamic a) = Dynamic $ f a >> ``` >> Source: https://www.reddit.com/r/haskell/comments/2kdcca/q_how_to_apply_a_polymorph… >> >> >> But now with GHC 8.8 as in my case, `Dynamic` constructor has changed its signature to: >> >> ```hs >> Dynamic :: forall a. TypeRep a -> a -> Dynamic >> ``` >> >> Which renders the `apD` not working anymore. >> >> >> And it seems missing dependencies now for an older solution Edward KMETT provides: >> >> ```hs >> apD :: forall f. Typeable1 f => (forall a. a -> f a) -> Dynamic -> Dynamic >> apD f a = dynApp df a >> where t = dynTypeRep a >> df = reify (mkFunTy t (typeOf1 (undefined :: f ()) `mkAppTy` t)) $ >> \(_ :: Proxy s) -> toDyn (WithRep f :: WithRep s (() -> f ())) >> ``` >> Source: https://stackoverflow.com/questions/10889682/how-to-apply-a-polymorphic-fun… >> >> >> So, how can I do that nowadays? >> >> Thanks, >> Compl >> >> _______________________________________________ >> ghc-devs mailing list >> ghc-devs(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs >

2 6

What's the modern way to apply a polymorphic function to a Dynamic value in GHC 8.8 and onwards?
by YueCompl 12 Apr '21

12 Apr '21

Dear Cafe and GHC devs, There used to be a "principled way with pattern match on the constructor": ```hs data Dynamic where Dynamic :: Typeable a => a -> Dynamic apD :: Typeable f => (forall a. a -> f a) -> Dynamic -> Dynamic apD f (Dynamic a) = Dynamic $ f a ``` Source: https://www.reddit.com/r/haskell/comments/2kdcca/q_how_to_apply_a_polymorph… But now with GHC 8.8 as in my case, `Dynamic` constructor has changed its signature to: ```hs Dynamic :: forall a. TypeRep a -> a -> Dynamic ``` Which renders the `apD` not working anymore. And it seems missing dependencies now for an older solution Edward KMETT provides: ```hs apD :: forall f. Typeable1 f => (forall a. a -> f a) -> Dynamic -> Dynamic apD f a = dynApp df a where t = dynTypeRep a df = reify (mkFunTy t (typeOf1 (undefined :: f ()) `mkAppTy` t)) $ \(_ :: Proxy s) -> toDyn (WithRep f :: WithRep s (() -> f ())) ``` Source: https://stackoverflow.com/questions/10889682/how-to-apply-a-polymorphic-fun… So, how can I do that nowadays? Thanks, Compl

2 1