Back to Questions
860
views1
comment
how can I "open" in a limited scope
f#

probably another stupid question here, but i'd
like to be able to have the functions from a particular module
(e.g. Microsoft.Collections.FSharp.LazyList) available
without having to use the long names, but i'm wondering
if there's a way to do that without polluting the namespace
of the entire program.

e.g. something like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

open LazyList in
    // return llist holding all the leading elements of l that satisfy the test f
    let llist_takef f l =
        let unf l =
            match l with
            | Cons(h, t) when f h ->
                Some(h, t)
            | _ ->
                None
    unfold unf l

open Seq, System.Collections.Generic, Option in
    // return seq holding all the leading elements of l that satisfy the test f
    let seq_takef f (l: #seq<'a>) =
        let nextelem (e: #IEnumerator<'a>) =
            if e.MoveNext() then
                partition f (Some e.Current) |> fst
             else
                 None
    generate l.GetEnumerator nextelem (fun _ -> ())

PS. regarding the actual functionality of the above code:
is the code reasonable, or is there a much easier way to
implement either function?

.

You can't do exactly what you want but there are a couple of alteratives that come close. Open statements only apply to the current module so you could create lots of small modules to reduce the scope of your open statements:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// compiles
module Foo =
    open LazyList
    // return llist holding all the leading elements of l that satisfy the test f
    let llist_takef f l =
        let unf l =
            match l with
            | Cons(h, t) when f h ->
                Some(h, t)
            | _ -> None
        unfold unf l
    
// doesn't compile - LazyList no longer open
// return llist holding all the leading elements of l that satisfy the test f
let llist_takef f l =
    let unf l =
        match l with
        | Cons(h, t) when f h ->
            Some(h, t)
        | _ ->
            None
    unfold unf l

Alteratively you can use the module keyword to give a shorter alias to a module:

1
2
3
4
5
6
7
8
9
10
11

module LL = LazyList

// return llist holding all the leading elements of l that satisfy the test f
let llist_takef f l =
    let unf l =
        match l with
        | LL.Cons(h, t) when f h ->
            Some(h, t)
        | _ ->
            None
    LL.unfold unf l

This would be my perfered solution as it saves typing out long module names, but still allows you to easily see where the values/functions are coming from.

By on 10/24/2007 6:29 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper