- Beginners - Haskell.org

Re: [Haskell-beginners] Are these soloutions all valid and a good use of Haskell
by Roelof Wobben 12 Nov '14

12 Nov '14

Oke, But what If I try it on a left folt. Then it must be the other way. let's say we have [1 , 2, 3] so first it's nothing and 1 is taken. so y could be one and nothuing must stay nothing because it's not the last part, The same for 2 , When it's three nothing must changed to just 3. Fold is something I find it very difficult to wrap my head around it. Maybe haskell or any functional proggramming language is not for me, Roelof Kees Bleijenberg schreef op 11-11-2014 15:46: > The program traverses the list from right to left. The first element that > acc sees during traversal is the last element of the list. > The idea is as follows: > Parameter y is the partial calcresult. > If y (in your code) is Nothing then acc returns Just x. So the new partial > result is the current list element in a Just. > The next time acc is called, y is not Nothing but a Just. In that case acc > returns the partial calcresult unchanged. > So, y is Nothing for the last list element and Just <last element of the > list> for all other list elements. > > last5 :: [a] -> Maybe a > last5 xs = foldr acc initial xs > > acc :: a -> Maybe a -> Maybe a > acc x Nothing = Just x > acc _ aJust = aJust > > initial :: Maybe a > initial = Nothing > > In your code you don’t need the ‘where’ in the acc definition. Define acc > for Nothing and for Just. > > Kees > > --------------- > Im now trying to make a rfold solution to this problem. > > Till now I have this : > > last5 :: [a] -> Maybe a > last5 xs = foldr acc initial xs > > acc :: a -> Maybe a -> Maybe a > acc x y = where > acc x Nothing = Just x > acc _ j = j > > initial :: Maybe a > initial = Nothing > > So still not working. > > Can someone explain to me in small steps how to figure out what the right > answer is to the acc part. > > Roelof > > > > > > > > > > Roelof Wobben schreef op 11-11-2014 8:20: > Thanks, this is working well. > > But just for understanding > > in the part acc x Nothing x is the input string, > and in the part _j means the same as (xs:x) > > Roelof > > > > Alex Hammel schreef op 10-11-2014 22:47: > It's an indentation issue. Make sure that there are no spaces before the bit > about 'last5 = foldr acc' etc. > > On Mon, Nov 10, 2014 at 12:48 PM, Roelof Wobben <r.wobben(a)home.nl> wrote: > Roelof Wobben schreef op 10-11-2014 20:59: > last5 :: [a] -> Maybe a > last5 = foldr acc Nothing where > acc x Nothing = Just x > acc _ j = j > > When I enter this in GHCI I see this error : > > Illegal type signature: ‘[a] -> Maybe a last5’ > > > > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners > > > > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners > > > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners >

3 2

Re: [Haskell-beginners] Are these soloutions all valid and a good use of Haskell
by Stefan Höck 11 Nov '14

11 Nov '14

> I try to say that if the input list has only 1 item the outcome is the head > of that list. This is not how one typically thinks about folds. Look at the type of acc: acc :: a -> Maybe a -> Maybe a acc is a function wich takes two arguments (ignoring currying): On is of type `a`. This is the element type of the list you fold over. The other is of type `Maybe a`. This is the value you accumulate in your fold. The initial value is `Nothing`. You start your fold literally with nothing, since you haven't visited any element in the list yet. Now the first element of the list (see below) is passed to acc. What do you do with it? acc a Nothing = ??? a is an element in your lit, Nothing is the value you have accumulated so far. What do you do? Ignore a? Keep it? If you ignore a, you return `Nothing`. acc a Nothing = Nothing With this accumulator, the list will be traversed (ignoring lazy evaluation for the time being), all values will be ignored and your result will be Nothing, no matter what kind of list you fold over. Therefore, let's keep value `a`. In order to do that, we have to wrap it in a Just, otherwise the types won't match: acc a Nothing = Just a This function will give the right result for empty lists (Nothing) and for lists with a single value where the value is wrapped in a Just. The function will throw an error however, if you pass it a list containing more than one element, because the pattern match is not exhaustive. We need to decide what happens, when we already have a value wrapped in a Just: acc a Just b = ??? Here you have three possibilities. a) return Just b, b) return Just a, c) return Nothing. These are all the options you have. Anything else (except for throwing errors) will not compile. You can try each of the three. One will give you the head of the list, one will give you the last item of the list, and one will give you Nothing for lists with more than one element. Note that the result of your function depends on which fold you use. foldl folds from the left. The first element passed to the accumulating function will be the head of the list. foldr folds from the right. The first value passed to the accumulating function is the last in the list. So, think about the fold like this: Every element of the list is passed to your accumulator and each time you must decide whether you want to keep it or let it pass. If you keep them all, you will in the end hold the last element passed to your accumulator. If you let them all pass (except for the first, which you keep since you still have Nothing), you will end up with the first element passed to you. If you fold from the right, the first element you get is the last in the list. Keep it and don't let it go. If you fold from the left, the first element will be the head of the list. Throw them all away except for the very last one. Feel free to ask, if this doesn't make sense. Stefan > Stefan Höck schreef op 10-11-2014 15:23: > >Just a quick note: That's 'typed holes' not 'type holes' ... > > > >On Mon, Nov 10, 2014 at 03:12:20PM +0100, Stefan Höck wrote: > >>Hi Roelof > >> > >>It seems like you try to do too many things at once. Here's how you > >>could go about this step-by-step and let GHC help you implement your > >>functions along the way: > >> > >>First, give the type signature of your function: > >> > >> last5 :: [a] -> Maybe a > >> last5 = undefined > >> > >>Now, load this into GHCi or compile with GHC. If it compiles, you're > >>on the right track. Now, you want to implement it using a fold > >>(try both, foldl and foldr): > >> > >> last5 :: [a] -> Maybe a > >> last5 xs = foldr _ _ xs > >> > >>The underscores are 'type holes'. This tells the compiler to give you > >>some information about what is supposed to be placed at the two > >>positions. For the moment, we are only interested in the types of the > >>things that go there. The compiler will tell you, that > >>the hole at the first position is of type > >> > >> a -> Maybe a -> Maybe a > >> > >>and the hole at the second position is of type > >> > >> Maybe a > >> > >>Now, instead of filling the holes in place, let's define two helper > >>functions together with their type signatures. You can later on inline > >>them in your definition of last5, but for the time being, let's get as > >>much help from the compiler as we can. > >> > >> last5 :: [a] -> Maybe a > >> last5 xs = foldr acc initial xs > >> > >> acc :: a -> Maybe a -> Maybe a > >> acc = undefined > >> > >> initial :: Maybe a > >> initial = undefined > >> > >>Again, compile or load into GHCi. If you did anything wrong, the > >>compiler will tell you so. There is only one possible way to > >>implement function `initial` without cheating (= raising an error) > >> > >> initial :: Maybe a > >> initial = Nothing > >> > >>Function `acc` can be implemented in several ways. Only one of them > >>will lead to the desired behavior. Finding out the proper implementation > >>is the main point of this folding-exercise. Try also an implementation > >>using foldl. Does it behave as expected? What are the differences > >>compared to foldr? When you feed your implementations a huge list - > >>say [1..20000000] - what happens? > >> > >>Note that whenever you get an error message in a rather complex > >>function implementation, move local function definitions and lambdas > >>to the top level, give them a type signature and implement them > >>separately one at a time. Use type holes to let the compiler give > >>assistance with type signatures and possible implementations. > >>Once everything compiles and runs as expected, move the toplevel > >>definitions back to where you'd like them best. > >> > >>Stefan > >> > >>PS: A more succint implementation of last5 would use currying: > >> > >> last5 = foldr acc initial > >> > >>PPS: If you get a stack overflow with very large lists, try > >> using foldl' from Data.List (or better, once you learned > >> about the Foldable type class, from Data.Foldable). > >> > >>On Mon, Nov 10, 2014 at 02:28:08PM +0100, Roelof Wobben wrote: > >>>I tried and so far I have this : > >>> > >>>last5 = foldl(\acc x -> if x=[] then x else acc xs) [] xs > >>> > >>>But now I get parse error on the -> part. > >>> > >>>Roelof > >>> > >>> > >>>Roelof Wobben schreef op 10-11-2014 13:47: > >>>>Thanks all, > >>>> > >>>>I will try to make a fold solution as soon as I see that functional > >>>>explained in the learnyouahaskell. > >>>> > >>>>Roelof > >>>> > >>>> > >>>>Frerich Raabe schreef op 10-11-2014 11:43: > >>>>>On 2014-11-10 11:16, Karl Voelker wrote: > >>>>>>On Mon, Nov 10, 2014, at 01:50 AM, Roelof Wobben wrote: > >>>>>>>What do you experts think of the different ways ? > >>>>>>2 and 4 are quite similar, and both fine. 3 is not so good: guards > >>>>>>provide weaker guarantees than patterns, and head and tail are partial > >>>>>>functions. > >>>>>In addition to what Karl wrote, I'd like to suggest not using the > >>>>>semicolon all the time -- it's not needed and just adds noise. > >>>>> > >>>>>>All three implementations have in common that they do their own > >>>>>>recursion. It would be a good exercise to try implementing last as a > >>>>>>fold - in other words, letting the standard library do the recursion > >>>>>>for > >>>>>>you. > >>>>>Right - I suggest trying to express the problem with the most abstract > >>>>>function first, then consider using a fold, then use manual recursion. > >>>>>in > >>>>>your particular case you could exploit that for non-empty lists, getting > >>>>>the last element of a list is the same as getting the first element of > >>>>>a reversed list (and there are ready-made functions for reversing a list > >>>>>and getting the first element of a list). > >>>>> > >>>>_______________________________________________ > >>>>Beginners mailing list > >>>>Beginners(a)haskell.org > >>>>http://www.haskell.org/mailman/listinfo/beginners > >>>> > >>>_______________________________________________ > >>>Beginners mailing list > >>>Beginners(a)haskell.org > >>>http://www.haskell.org/mailman/listinfo/beginners > >>> > >_______________________________________________ > >Beginners mailing list > >Beginners(a)haskell.org > >http://www.haskell.org/mailman/listinfo/beginners > > >

7 17

Haskell and LiveCode
by Frank 11 Nov '14

11 Nov '14

How do the 2 languages compare? -- P.S.: I prefer to be reached on BitMessage at BM-2D8txNiU7b84d2tgqvJQdgBog6A69oDAx6

1 0

Are these soloutions all valid and a good use of Haskell
by Roelof Wobben 11 Nov '14

11 Nov '14

Hello, I tried to solve the first problem of the 99 haskell problems on 3 seperate ways. The problem is that I have to find the last item of a list. The solutions I found with a little help of this mailinglist are : last2::[a]-> Maybe a; last2 [] = Nothing; last2 ([x]) = Just x; last2 (_:xs) = last2 xs last3::[a]-> Maybe a; last3 x | null x = Nothing | null xs = Just (head x) | otherwise = last3 (tail x) where xs = tail x last4::[a]-> Maybe a; last4 x = case x of [] -> Nothing ; [x] -> Just x ; (_:xs) -> last4 xs main = print $ (last2 [] ) What do you experts think of the different ways ? Roelof

7 14

First Project: Imperative Algorithm Visualization tool
by Adit Biswas 10 Nov '14

10 Nov '14

I'm kindoff a beginner in haskell, I've mostly just been exploring the language, some of the introductory books on the subject and writing some small programs. This is one of my first projects I wanted to try out, but I'm feeling a bit lost on how to go about doing it. I want to build a tool which takes in inputs describing algorithms, probably in their imperative form and generate animations using SVG and HTML5 preferably or OpenGL. I find that being able to visualize the execution of an algorithm helped me understand the material a few years ago when i started college but I mostly had to do these on pen and paper. So my higher level idea on approaching this problem is: 1. Create a dsl for describing data structures, e.g Link lists, trees, graphs 2. Create a dsl for describing each step of the algorithms manipulating the data structures 3. The algorithms would be a monadic composition of the step ADTs 4. Lift the algorithm to some monad which carries out the side effects of making changes to a visualization. I'm sorry if I didn't use all the correct terminology for describing the problem, I'm not completely sure if it's an appropriate approach. My logic was that Since each state of the visualization is a sideeffect of executing an algorithm, it would be a seperate monad like IO, the entire algorithm can be represented as some form of a graph, I should have data types representing each component of the graph. I have no idea how to go about designing a DSL or for designing a monad which will handle the animations. Could someone help me approach the solution and what topics I want to look at to understand how to build the solution. Feel free to let me know if you'd like to help work on the tool, or if you think I should simplify my project in some way. This is mostly just an idea for a project and since I'm feeling pretty beginnerish with the language, i wouldnt love suggestions on a simpler project which can sorta lead me in a direction in which i can make this tool in the future. Thank You! -- Adit Biswas

4 3

invalid type signature last2::: [a] -> a
by Roelof Wobben 10 Nov '14

10 Nov '14

Hello, I try to solve the 99 haskell problems on several ways. But my first try which looks like this : Last2::[a]-> a Last2:: last[list] gives the following error message : src/Main.hs@1:1-1:6 Invalid type signature: Last2 :: [a] -> a Should be of form <variable> :: <type> What am trying to do is say the input is a list which can be of integers or chars so everything is the output can then also be of type everything. Roelof

5 8

Re: [Haskell-beginners] Lazy state + IO not lazy?
by Jan Snajder 04 Nov '14

04 Nov '14

Dear all, On 10/27/14, Kim-Ee Yeoh <ky3(a)atamo.com> wrote: Kim-Ee, many thanks for your reply and sorry for my delayed reaction. > Consider > > let u = return () :: IO () in > expr >> u > > where expr ranges over (return undefined), (undefined), and (error "urk"). Ok, so this is what we get: (1) return undefined >> return () :: IO () ==> evaluates to 'IO ()' (2) > undefined >> return () *** Exception: Prelude.undefined (3) > error "urk" >> return () *** Exception: ur > Are their executions surprising? In my understanding, in a strict state monad, the '>>' operator will evaluate the (value,state) pair of the left expression up to the (,) constructor. Assuming this is correct, in (1) 'return undefined' gives a '(undefined,state)', which is not evaluated further, hence the computation continues. In (2), there is no 'return' to create a (value,state) pair, so when '>>' tries to evaluate the left expression, it evaluates directly to undefined. The same holds for error, which (I guess) stops the execution immediately upon being evaluated. Is my reasoning correct? > Compare to > > let u = return () :: State Int () in > evalState (expr >> u) 0 > > for both strict and lazy state. Ok, here we go: > Strict.evalState (return undefined >> return () :: Strict.State Int ()) 0 () > Strict.evalState (undefined >> return () :: Strict.State Int ()) 0 *** Exception: Prelude.undefined > Strict.evalState (error "urk" >> return () :: Strict.State Int ()) 0 *** Exception: urk > Lazy.evalState (return undefined >> return () :: Lazy.State Int ()) 0 () > Lazy.evalState (undefined >> return () :: Lazy.State Int ()) 0 () > Lazy.evalState (error "urk" >> return () :: Lazy.State Int ()) 0 () So, strict-state monad matches the behavior of 'IO', which is what I expected because I know 'IO' is a strict-state monad. Furthermore, lazy-state monad never inspects the left argument of '>>', so all three cases compute. > IO above matches one of them. Suppose > IO's behavior matches the other, what happens? I guess the IO monad would behave in an undesirable way because we would not be able to raise an exception nor catch undefined computations. Is that what you meant? > Now with the definition of mapM in mind, consider the difference > between your original: > > Lazy.evalStateT (head `fmap` mapM return (1:undefined)) 0 > > and > > Lazy.evalStateT (head `fmap` mapM return [1,undefined]) 0 > > Did you mean the latter? No, that's not what I meant. But I assume that in the latter case we won't get a bottom because we don't evaluate beyond the spine of the list: > Lazy.evalState (head `fmap` mapM return [1,undefined]) 0 1 > Lazy.evalStateT (head `fmap` mapM return [1,undefined]) 0 1 Is my interpretation correct? But what confuses me why we get different behavior here: > Lazy.evalState (head `fmap` mapM return (1:undefined)) 0 1 > Lazy.evalStateT (head `fmap` mapM return (1:undefined)) 0 *** Exception: Prelude.undefined From this I conclude that the second monad is strict, whereas the first is not. Is that correct? Assuming that is correct, does this mean that every monad stacked on top of an IO monad becomes strict?? Here's another example that illustrates this point: http://pastebin.com/0fAFmufA Why is (4) not computed in constant space, whereas (3) is? Finally, what ultimately bothers me is the following: is it true that if my state monad is built on top of an IO monad I cannot lazily consume a result of a mapM computation? (Here I am assuming, perhaps wrongly, that if '>>=' is non-strict in its left argument, then 'sequence' is tail recursive modulo cons. But I'm actually not convinced why this should be the case.) Many thanks for any input! Cheers, Jan

2 1

Installation problems
by Jeffrey Brown 29 Oct '14

29 Oct '14

Hi, In trying to install Tidal, following something that worked for someone else who was getting an error similar to one I got, I ran ghc-clang-wrapper <https://gist.github.com/mzero/7245290#file-ghc-clang-wrapper>. I believe it was after that that cabal install stopped working, and I lost a lot of libraries that used to exist, such as Sound.MIDI: GHCi, version 7.8.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> import Sound.MIDI <no location info>: Could not find module ‘Sound.MIDI’ It is not a module in the current program, or in any known package. Prelude> When I try to reinstall a library that used to exist -- e.g. "hosc", below -- via cabal install, I now get a giant slew of failures. Any ideas? Many thanks, Jeff sh-3.2# cabal install hosc Resolving dependencies... In order, the following will be installed: binary-0.7.2.2 (new version) data-binary-ieee754-0.4.4 (reinstall) changes: base-4.7.0.1 added, binary-0.7.2.2 added network-2.6.0.2 (new package) text-1.2.0.0 (new package) blaze-builder-0.3.3.4 (reinstall) changes: base-4.7.0.1 added, bytestring-0.10.4.0 added, text-1.2.0.0 added hosc-0.15 (new version) Warning: Note that reinstalls are always dangerous. Continuing anyway... Downloading binary-0.7.2.2... Configuring network-2.6.0.2... Configuring text-1.2.0.0... Failed to install network-2.6.0.2 Build log ( /var/root/.cabal/logs/network-2.6.0.2.log ): Failed to install text-1.2.0.0 Build log ( /var/root/.cabal/logs/text-1.2.0.0.log ): Configuring binary-0.7.2.2... Failed to install binary-0.7.2.2 Build log ( /var/root/.cabal/logs/binary-0.7.2.2.log ): cabal: Error: some packages failed to install: binary-0.7.2.2 failed during the configure step. The exception was: user error (<command line>: cannot satisfy -package-id Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff: Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff is unusable due to missing or recursive dependencies: base-4.7.0.1-df210ede1eb79477fef5662549c32927 bytestring-0.10.4.0-4aa78c8ca7b6b65993eefc131f7d94fa containers-0.5.5.1-0d8db9193d3e3371e0142bcc8a4a0721 deepseq-1.3.0.2-8f63133c1b77f3b3190f04893cf340e4 directory-1.2.1.0-af5afa2b9b551d3fec1a32d6bfd8bd72 process-1.2.0.0-3a472e9c66165e506513ea8f145681a0 time-1.4.2-d6766dce59812a4b19375d9595549a8b unix-2.7.0.1-8adde3f1f2079286da56b30898c2d703 (use -v for more information) ) blaze-builder-0.3.3.4 depends on text-1.2.0.0 which failed to install. data-binary-ieee754-0.4.4 depends on binary-0.7.2.2 which failed to install. hosc-0.15 depends on binary-0.7.2.2 which failed to install. network-2.6.0.2 failed during the configure step. The exception was: user error (<command line>: cannot satisfy -package-id Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff: Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff is unusable due to missing or recursive dependencies: base-4.7.0.1-df210ede1eb79477fef5662549c32927 bytestring-0.10.4.0-4aa78c8ca7b6b65993eefc131f7d94fa containers-0.5.5.1-0d8db9193d3e3371e0142bcc8a4a0721 deepseq-1.3.0.2-8f63133c1b77f3b3190f04893cf340e4 directory-1.2.1.0-af5afa2b9b551d3fec1a32d6bfd8bd72 process-1.2.0.0-3a472e9c66165e506513ea8f145681a0 time-1.4.2-d6766dce59812a4b19375d9595549a8b unix-2.7.0.1-8adde3f1f2079286da56b30898c2d703 (use -v for more information) ) text-1.2.0.0 failed during the configure step. The exception was: user error (<command line>: cannot satisfy -package-id Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff: Cabal-1.20.0.2-b862897337f86101d0e1a35135984eff is unusable due to missing or recursive dependencies: base-4.7.0.1-df210ede1eb79477fef5662549c32927 bytestring-0.10.4.0-4aa78c8ca7b6b65993eefc131f7d94fa containers-0.5.5.1-0d8db9193d3e3371e0142bcc8a4a0721 deepseq-1.3.0.2-8f63133c1b77f3b3190f04893cf340e4 directory-1.2.1.0-af5afa2b9b551d3fec1a32d6bfd8bd72 process-1.2.0.0-3a472e9c66165e506513ea8f145681a0 time-1.4.2-d6766dce59812a4b19375d9595549a8b unix-2.7.0.1-8adde3f1f2079286da56b30898c2d703 (use -v for more information) )

1 1

Haskell typing question
by Cui Liqiang 28 Oct '14

28 Oct '14

Thanks for your help, your suggestion works. But I still don’t quite understand. In the following line: caluDecimal l = (foldr1 (\x acc -> acc / 10.0 + x) (map digitToInt l)), After applying digitToInt, the type of ‘x’ in the expression above is Int indeed, but Haskell consider the ’10.0’ to be a Int, is it? ---------------------------------------------------------------------------------------------------------------------------- Hi, I am doing an exercise in Haskell, which is converting a string like ?$123.312? to double value. Below is my code: module Main where import Data.Char caluInt l = foldl1 (\acc x -> acc * 10 + x) (map digitToInt l) caluDecimal l = (foldr1 (\x acc -> acc / 10.0 + x) (map digitToInt l)) convert(x:xs) = let num = [e | e <- xs, e /= ','] intPart = takeWhile (/='.') num decimalPart = tail(dropWhile (/='.') num) in (caluInt intPart) + (caluDecimal decimalPart) And I got an error in this line: caluDecimal l = (foldr1 (\x acc -> acc / 10.0 + x) (map digitToInt l)), which says: No instance for (Fractional Int) arising from a use of `/' Possible fix: add an instance declaration for (Fractional Int) In the first argument of `(+)', namely `acc / 10.0' In the expression: acc / 10.0 + x In the first argument of `foldr1', namely `(\ x acc -> acc / 10.0 + x)' Why Haskell insists that 10.0 is a Int? How can I explicitly tell Haskell I want a Fractional? -- Cui Liqiang > Why Haskell insists that 10.0 is a Int? How can I explicitly tell Haskell > I want a Fractional? Because digitToInt means exactly what it says. If you want it to become something other than Int, apply fromIntegral to its result.

2 2

Cabal-install of local package
by Stefan Höck 28 Oct '14

28 Oct '14

Dear list Like many other I seem to be struggling with some of the concepts of cabal and cabal-install. For the records: I use cabal-install 1.20.0.3 and ghc 7.8.3 on arch linux. For starters, I implemented my own idea of an improved prelude, called the package efa-prelude and the module it exports Efa.Prelude. I then built the package and installed it using `cabal install --user`. This worked and a folder for the library was created at "$HOME/.cabal/lib/x86_64-linux-ghc-7.8.3/efa-prelude-0.1.0". I also registered the library using `cabal register --user` and now cabal prints some information about the package when I type `cabal info efa-prelude`. I am also able to import Efa.Prelude into ghci. However, when I now try to use this library in another local project using a sandbox this time, I can build the project but when I try to install it into the sandbox I get the following error message: Resolving dependencies... cabal: Could not resolve dependencies: trying: test-0.1.0 (user goal) next goal: efa-prelude (dependency of test-0.1.0) Dependency tree exhaustively searched. I just tried and the install works if I do it outside of a sandbox. Obviously I am missing something crucial here. Could somebody please point me in the right direction what is needed to make my own packages available in a sanboxed install? Thanks for your time Stefan

1 1